home *** CD-ROM | disk | FTP | other *** search
/ TeX 1995 July / TeX CD-ROM July 1995 (Disc 1)(Walnut Creek)(1995).ISO / dviware / dvi2ps / dvi-to-ps / dvi2ps.c < prev    next >
C/C++ Source or Header  |  1990-10-01  |  75KB  |  2,542 lines
  1. #define VERSION "2.10gf"
  2. /* modified by Peter Damron 1987 University of Washington */
  3. /*---------------------------------------------------------------------*/
  4. /* $Header: dvi2ps.c,v 2.1 88/06/08 14:12:24 peterd Rel2 $ */
  5. /*---------------------------------------------------------------------*/
  6. #ifndef lint
  7. static char rcsid[] = "$Header: dvi2ps.c,v 2.1 88/06/08 14:12:24 peterd Rel2 $";
  8. #endif lint
  9. /*---------------------------------------------------------------------*/
  10. /*
  11.  * AUTHOR(s)
  12.  *     Mark Senn wrote the early versions of this program for the
  13.  *     BBN BitGraph.  Stephan Bechtolsheim, Bob Brown, Richard
  14.  *     Furuta, James Schaad and Robert Wells improved it.  Norm
  15.  *     Hutchinson ported the program to the Sun.  Neal Holtz ported
  16.  *     it to the Apollo, and from there to producing PostScript
  17.  *     output. Scott Jones added intelligent font substitution.
  18.  *     Howard Trickey made it read GF files instead of PXL ones.
  19.  *
  20.  */
  21.  
  22. /*---------------------------------------------------------------------*/
  23. /* Basic method:
  24.  * Using the local font cacheing machinery that was in the previewer,
  25.  * we can easily manage to send the bitmap for each chracter only once.
  26.  * Two passes are made over each page in the DVI file.  The first pass
  27.  * simply outputs the bitmaps for all characters on that page that haven't
  28.  * been sent before.  The second pass outputs all the character setting
  29.  * and positioning commands.  This allows us to bracket the setting portion
  30.  * with PostScript save's and restore's, thus reclaiming considerable
  31.  * virtual memory after each page.
  32.  *
  33.  * All coordinates are output in the PostScript system (TeX origin),
  34.  * and in integer units of rasters (300/inch) -- except for character
  35.  * widths, which are sent as floating point numbers.
  36.  *
  37.  * About 2 pages of PostScript support code must be sent to the LaserWriter
  38.  * before this stuff goes.  It is automatically included unless the
  39.  * -h option is given.
  40.  */
  41.  
  42. /*---------------------------------------------------------------------*/
  43. /* Change log:
  44.  *
  45.  * Early 1985, (nmh) -- ported sun version to Apollo. 
  46.  * A little later (nmh) -- changed to continue on in the event of missing
  47.  *        font files.
  48.  * 30-Mar-85 (nmh) -- added -a option to specify a different PXL area
  49.  * 30-Mar-85 (nmh) -- changed default PXL area to /pxl118
  50.  * 31-Mar-85 (nmh) -- fixed bug in OpenFontFile() regarding more than MAXOPEN
  51.  *              PXL files -- changed to mark files as closed in font_entry.
  52.  *  7-Apr-85 (nmh) -- made command line argument decoding case insensitive.
  53.  *              cleaned up handling of DVI file name argument.
  54.  * 30-May-85 (nmh) -- new version; hacked to output PostScript commands
  55.  *  6-Jun-85 (nmh) -- added relative positioning (20% smaller PostScript output)
  56.  *              add -m option to specify mag
  57.  * 11-Jun-85 (nmh) -- fixed bug regarding char spacings in very long "words"
  58.  * 12-Jun-85 (nmh) -- v1.02 - process DVI pages in reverse order
  59.  * 13-Jun-85 (nmh) -- fixed bug re PXL files getting opened too often when no PreLoad
  60.  * 14-Jun-85 (nmh) -- font dict created in PostScript only when 1st char of font downloaded
  61.  *              add -m0 -mh -m1 etc. to specify magsteps
  62.  * 16-Aug-85 (nmh) -- added -c option t0 create output file in spool area (Apollo specific)
  63.  *              added -h option to copy header file to output
  64.  *              added -o option to pass options through to PostScript
  65.  * 20-Aug-85 (nmh) -- v1.03
  66.  * 24-Aug-85 (nmh) -- add -q option (for quiet operation).
  67.  *              changed -o option to check PostScript option
  68.  *              changed to output coordinates in TeX system (but
  69.  *              scaled to raster units) -- (0,0) at 1" in and down from
  70.  *        top left (better for use with different size paper).
  71.  *           -- v2.00
  72.  * 25-Aug-85 (nmh) -- added dictionary enclosure to Tex.ps, and output
  73.  *        suitable prolog here.
  74.  * 26-Aug-85 (nmh) -- changes to tex.ps to support Macintosh documents.
  75.  * 14-Sep-85 (nmh) -- added keyword=value decoding to \special;
  76.  * 15-Sep-85 (nmh) -- added -i file option.
  77.  * 23-Sep-85 (saj) -- added font substitution for case when font is
  78.  *              unavailable at requested mag. (a frequent occurrence
  79.  *              with some macro packages like LaTeX)
  80.  *  7-Jun-86 (hwt) -- use gf files ("pxl" survives in variable names)
  81.  *  8-Aug-86 (rkf) -- merged together the pxl and the gf versions.  Define
  82.  *              USEPXL should you want PXL files---gf is the default
  83.  *  14-Dec-87 (peterd) -- Changed sub-directory structure used by findfile.
  84.  *            Style names are used for subdirectories, not style
  85.  *            plus design size.
  86.  *            Changed font substitutions to compare <design size>
  87.  *            * <mag size>, not design and mag separately.
  88.  *            Changed all progress messages to go through Progress().
  89.  *            Changed all warning messages to go through Warning().
  90.  *            Note that Stats and Debug still use stderr.
  91.  *            Added support for font paths (multiple -a options).
  92.  *            Added support for environment variable for font path.
  93.  */
  94.  
  95. /* This version purports to drive a PostScript device (slowly) */
  96.  
  97. /**********************************************************************/
  98. /***********************  external definitions  ***********************/
  99. /**********************************************************************/
  100.  
  101. #include <stdio.h>
  102. #include <ctype.h>
  103. #include <strings.h>
  104. #include <signal.h>
  105. #include <sys/file.h>
  106. #include <sys/param.h>
  107. #include "dvi2ps.h"
  108. #include "font.h"
  109. #include "commands.h"
  110. #include "findfile.h"
  111. #include "gf.h"
  112.  
  113. /* why is this not included from c libs? */
  114. extern char *getenv();
  115.  
  116. #ifdef NOTDEF
  117. extern int  access();
  118. extern char *malloc();
  119. extern int  free();
  120. extern char *logname();
  121. #endif NOTDEF
  122.  
  123. /**********************************************************************/
  124. /************************  Global Definitions  ************************/
  125. /**********************************************************************/
  126.  
  127. /* default font area (directory) */
  128. #ifndef FONTAREA
  129. #define  FONTAREA    "/usr/local/lib/tex/fonts"
  130. #endif FONTAREA
  131.  
  132. /* name for environment variable for tex font path/directory */
  133. #ifndef ENVTEXFONTS
  134. #define ENVTEXFONTS    "TEXFONTS"
  135. #endif ENVTEXFONTS
  136.  
  137. /* default header file location */
  138. #ifndef HDRFILE
  139. #define HDRFILE        "/usr/local/lib/tex.ps"
  140. #endif HDRFILE
  141.  
  142. #ifdef apollo
  143. #ifndef SPOOLFILE
  144. #define SPOOLFILE    "/local/spool/laser/tex."
  145. #endif not SPOOLFILE
  146. #define MAXFLEN 28
  147. #endif apollo
  148.  
  149. #ifdef apollo
  150. #define  MAXOPEN     45    /* limit on number of open font files */
  151. #else !apollo
  152. #define  MAXOPEN     12    /* limit on number of open font files */
  153. #endif !apollo
  154.  
  155. #ifdef apollo       /* define for enabling of -c option (create output file) */
  156. #define CREOPT
  157. #endif apollo
  158.  
  159. #define USEGLOBALMAG 1            /* when defined, the dvi global */
  160.                     /*   magnification is applied   */
  161.     /* We can leave USEGLOBALMAG undefined when we have a limited
  162.        number of font magnifications (at 300dpi) available.  Otherwise, we
  163.        will simply complain about missing font files
  164.      */
  165. /* #undef USEGLOBALMAG */
  166.     /* define for "optimal" relative postioning, rather
  167.        than absolute.  Relative can reduce size of postcript
  168.        output 20% (and reduce print time by almost as much */
  169.  
  170. #define USERELPOS    1 
  171.  
  172. #define DEBUG   1            /* for massive printing of input */
  173.                     /* trace information; select by -d */
  174.                     /* option after filename: */
  175.                     /* dviview filename -d */
  176. #define STATS        /* to enable statistics reporting via -s option */
  177.  
  178. #define MACROS        /* use macros for some of the low level routines */
  179.  
  180. #define BINARYOPEN fopen        /* byte-oriented host version */
  181.  
  182. #define ARITHRSHIFT 1       /* define if ">>" operator is a */
  183.                     /* sign-propagating arithmetic  */
  184.                     /*   right shift */
  185.  
  186. #define  RESOLUTION      300
  187. #define  hconvRESOLUTION 300
  188. #define  vconvRESOLUTION 300
  189.  
  190. #ifdef NOTDEF
  191. #define  MAXFONTCHARS    128
  192. #define  PXLID        1001
  193. #endif NOTDEF
  194.  
  195. #define  DVIFORMAT    2
  196.  
  197. #define  STACKSIZE    100
  198. #define  STRSIZE    257
  199. #define  PATHSIZE    50
  200.  
  201. #define  NONEXISTANT    -1    /* offset for font files not found */
  202. #define  NO_FILE    (FILE *)-1
  203.  
  204. #define  TRUE        1
  205. #define  FALSE        0
  206.  
  207. /* define constants for fseek() */
  208. #define FROM_START    0
  209. #define FROM_HERE    1
  210. #define FROM_END    2
  211.  
  212. /**********************************************************************/
  213. /***********************  external definitions  ***********************/
  214. /**********************************************************************/
  215. /* macro definitions */
  216.  
  217. #define NEW(A) ((A *) malloc(sizeof(A)))
  218.  
  219. #define EQ(a,b) (strcmp(a,b)==0)
  220.  
  221.             /* output a formatted string */
  222. #define EMIT      fprintf
  223.             /* output a simple string */
  224. #define EMITS(s)  fputs(s,G_outfp)
  225.             /* output an escaped octal number */
  226. #define EMITO(c)  PutOct(c)
  227.             /* output a decimal integer */
  228. #define EMITN(n)  PutInt(n)
  229.             /* output a byte value in Hex */
  230. #define EMITH(h)  putc(*(digit+((h>>4)&0xF)),G_outfp),\
  231.           putc(*(digit+(h&0xF)),G_outfp)
  232.             /* output a single character */
  233. #define EMITC(c)  putc(c,G_outfp)
  234.             /* output a scaled X dimension */
  235. #define EMITX(x)  PutInt(PixRound(x,G_hconv))
  236.             /* output a scaled Y dimension */
  237. #define EMITY(y)  PutInt(PixRound(y,G_vconv))
  238.  
  239.             /* formatted i/o was killing us, so build some tables */
  240. char    *digit = "0123456789ABCDEF";
  241.  
  242. /* intended as replacements to NoSignExtend */
  243. /* may not be transportable */
  244. #define GET1(fp)  (int)(getc(fp))
  245. #define GET2(fp)  NoSignExtend(fp,2)
  246. #define GET3(fp)  NoSignExtend(fp,3)
  247. #define GET4(fp)  NoSignExtend(fp,4)
  248.  
  249. #ifdef NOTDEF
  250. /* may not be transportable or even work */
  251. #define GET2(fp)  ((getc(fp)<<8) | getc(fp))
  252. #define GET3(fp)  ((getc(fp)<<16) | (getc(fp)<<8) | getc(fp))
  253. #define GET4(fp)  ((getc(fp)<<24) | (getc(fp)<<16) | (getc(fp)<<8) | getc(fp))
  254. #define UNGET1(fp,ch)  fseek(fp, -1, FROM_HERE)
  255. #endif NOTDEF
  256.  
  257. #define GETN(fp,n)  NoSignExtend(fp,n)
  258. #define GETSN(fp,n)  SignExtend(fp,n)
  259.  
  260. #define UNGET1(fp,ch)  ungetc(ch,fp)
  261. #define SKIP(fp,n)  fseek(fp,n,FROM_HERE)
  262.  
  263. /*---------------------------------------------------------------------*/
  264. /* convertion to macro */
  265.  
  266. #ifdef MACROS
  267. #define PixRound(x,conv)  ((int)((x + (conv >> 1)) / conv))
  268. #define MoveDown(a)  G_v += a;
  269. #define MoveOver(b)  G_h += b;
  270. #endif MACROS
  271.  
  272. /**********************************************************************/
  273. /*************************  Global Variables  *************************/
  274. /**********************************************************************/
  275.  
  276. /* file name stuff */
  277. FILE *G_dvifp  = NULL;        /* DVI file pointer */
  278. FILE *G_outfp = NULL;        /* output file */
  279. char G_filename[STRSIZE];    /* DVI file name */
  280. char G_rootname[STRSIZE];    /* DVI filename without extension */
  281. char G_Logname[STRSIZE];    /* name of log file, if created */
  282. int  G_logging = FALSE;        /* Are we logging into a file? */
  283. FILE *G_logfp = NULL;        /* log file pointer (for errors) */
  284. char G_progname[STRSIZE];    /* this program name (dvi2ps) */
  285. int  G_quiet = FALSE;        /* for quiet operation */
  286. int  G_nowarn = FALSE;        /* don't print out warnings */
  287. long G_ppagep;            /* previous page pointer */
  288. #ifdef CREOPT
  289. int  G_create = FALSE;        /* create an output file in spool area ? */
  290. char G_outfname[STRSIZE];    /* name of output file */
  291. #endif CREOPT
  292.  
  293. /* status stuff */
  294. int  G_errenc = FALSE;        /* has an error been encountered? */
  295. int  G_ndone = 0;        /* number of pages converted */
  296.  
  297. /* measurement stuff */
  298. int  G_hconv;            /* converts DVI units to pixels - horiz. */
  299. int  G_vconv;            /* converts DVI units to pixels - vertical */
  300. int  G_h;            /* current horizontal position */
  301. int  G_hh = 0;            /* current h on device */
  302. int  G_v;            /* current vertical position */
  303. int  G_vv = 0;            /* current v on device */
  304. int  D_mag;            /* magnification(*1000) specified in preamble */
  305. int  D_num;            /* numerator specified in preamble */
  306. int  D_den;            /* denominator specified in preamble */
  307.  
  308. /* font stuff */
  309. int   G_nopen = 0;        /* number of open font files (pxl/gf) */
  310. struct open_font_list G_font_files[MAXOPEN];
  311. struct font_entry *G_prevfont=NULL;    /* font_entry pointer, previous font */
  312. struct font_entry *G_fontptr;        /* font_entry pointer, current font */
  313. struct font_entry *G_hfontptr=NULL;    /* head of font_entry pointer list */
  314. struct font_entry *G_pfontptr = NULL;    /* previous font_entry pointer */
  315.                 /* list of open font file identifiers */
  316. long  G_postambleptr;        /* Pointer to the postamble */
  317. FILE *G_fontfp;            /* font file pointer */
  318. char *G_fontpath[PATHSIZE];    /* a list of directories for fonts */
  319. int   G_fontpathsize = 0;        /* number of directories on font path */
  320.  
  321. /* command line stuff */
  322. int  CL_FirstPage = -1000000;     /* first page to print (uses count0)   */
  323. int  CL_LastPage = 1000000;       /* last page to print        */
  324. int  CL_header = TRUE;        /* copy header file to output? */
  325. int  CL_ncopies = 1;        /* number of copies to print */
  326. int  CL_nif = 0;        /* number of files to include */
  327. char *CL_Ifile[PATHSIZE];    /* files to include */
  328. int  CL_nps = 0;        /* number of PostScript commands to send */
  329. char *CL_PScmd[PATHSIZE];    /* PostScript commands to send */
  330. int  CL_Reverse = TRUE;    /* process DVI pages in reverse order ? */
  331. int  CL_usermag = 0;          /* user specified magnification */
  332. int  CL_PreLoad = TRUE;        /* preload the font descriptions? */
  333.  
  334. /* statistics stuff */
  335. #ifdef STATS
  336. int  Stats = FALSE;        /* are we reporting stats ? */
  337. int  S_nbpxl = 0;        /* # of bytes of pixel data */
  338. int  S_onbpx = 0;        /* "optimal" number of bytes of pixel data  */
  339. int  S_ndc = 0;            /* # of different characters typeset*/
  340. int  S_tnc = 0;            /* total # of chars typeset */
  341. int  S_nbpx0, S_ndc0, S_tnc0;    /* used for printing incremental changes per dvi page */
  342. #endif STATS
  343.  
  344. #ifdef DEBUG
  345. int Debug = 0;            /* print debugging info if true */
  346. #endif DEBUG
  347.  
  348. /*---------------------------------------------------------------------*/
  349.  
  350. /**********************************************************************/
  351. /*******************************  main  *******************************/
  352. /**********************************************************************/
  353.  
  354. main(argc, argv)
  355. int argc;
  356. char *argv[];
  357.  
  358. {
  359.     struct stack_entry {  /* stack entry */
  360.     int h, v, w, x, y, z;  /* what's on stack */
  361.     };
  362.  
  363.  
  364.     register int command;    /* current command */
  365.     int count[10];        /* the 10 counters at begining of each page */
  366.     long cpagep;        /* current page pointer */
  367.     int  Emitting = FALSE;    /* are we outputting typsetting instructions? */
  368.     register int i;        /* command parameter; loop index */
  369.     register int k;        /* temporary parameter */
  370.                 /* what happens on pass 0? */
  371.     int PassNo = 0;        /* which pass over DVI page? (0,1) */
  372.     int SkipMode = FALSE;    /* in skip mode flag (page not converted) */
  373.     register int sp;        /* stack pointer */
  374.     struct stack_entry stack[STACKSIZE];    /* stack */
  375.     char SpecialStr[STRSIZE];    /* "\special" strings      */
  376.     char *tchp;            /* temporary character pointer */
  377.     register int val;        /* temporary to hold command information */
  378.     register int val2;        /* temporary to hold command information */
  379.     int w;            /* current horizontal spacing (w-reg) */
  380.     int x;            /* current horizontal spacing (x-reg) */
  381.     int y;            /* current vertical spacing (y-reg) */
  382.     int z;            /* current vertical spacing (z-reg) */
  383.  
  384.     /* set program name - for error messages */
  385.     if ((tchp = rindex(argv[0],'/')) == 0) {
  386.         strcpy(G_progname, argv[0]);
  387.     } else {
  388.         strcpy(G_progname, tchp+1);
  389.     }
  390.  
  391.     /* set up default font directory on path */
  392.     G_fontpath[0] = FONTAREA;
  393.     G_fontpathsize = 1;
  394.  
  395.     /* interpret the command line */
  396.     DecodeArgs(argc,argv);
  397.  
  398. #ifdef apollo
  399.     set_sbrk_size( 2048*1024 );
  400. #endif apollo
  401.  
  402.     /* check for presence of pre-amble */
  403.     CheckPreAmble();
  404.  
  405.     /* create output file */
  406. #ifdef CREOPT
  407.     if( G_create )
  408.     G_outfp = OpenOutput();
  409.     else
  410. #endif CREOPT
  411.     G_outfp = stdout;
  412.  
  413. /* it is important that these be the very first things output !!! */
  414.  
  415.     /* copy the postscript header file to output */
  416.     if( CL_header ) {
  417.     CopyFile( HDRFILE );
  418.     }
  419.  
  420.     /* copy all included user files - from command line */
  421.     for( i=0; i<CL_nif; i++ ) {
  422.     CopyFile( CL_Ifile[i] );
  423.     }
  424.  
  425.     /* start output */
  426.     EMITS("TeXDict begin @start\n");
  427.     EMIT(G_outfp, "%%%%Title: %s\n", G_filename);
  428.     EMIT(G_outfp, "%%%%Creator: %s\n", G_progname);
  429.     EMITS("%%EndProlog\n");
  430.  
  431.     /* prefix valid PostScript options with a "@" - from command line */
  432.     for (i=0; i<CL_nps; i++) {
  433.     if( ChkOpt(CL_PScmd[i]) ) {
  434.         EMIT(G_outfp, "@%s\n", CL_PScmd[i]);
  435.     } else {
  436.         Fatal("%s is an invalid PostScript option\n", CL_PScmd[i] );
  437.     }
  438.     }
  439.  
  440.     /* multiple copies ? */
  441.     if (CL_ncopies > 1) EMIT(G_outfp, "%d @copies\n", CL_ncopies);
  442.  
  443.     /* read the pre-amble (and postamble) info */
  444.     ReadPreAmble();
  445.  
  446.     PassNo = 0;
  447.     
  448.     /* interpret the dvi file byte code commands */
  449.     while (TRUE)
  450.  
  451.     switch (command=GET1(G_dvifp))  {
  452.  
  453.     case SET1:case SET2:case SET3:case SET4:
  454.         val = GETN(G_dvifp, command-SET1+1);
  455.         if (!SkipMode) SetChar(val, command, PassNo);
  456.         break;
  457.  
  458.     case SET_RULE:
  459.         val = GET4(G_dvifp);
  460.         val2 = GET4(G_dvifp);
  461.         if (Emitting) SetRule(val, val2, TRUE);
  462.         break;
  463.  
  464.     case PUT1:case PUT2:case PUT3:case PUT4:
  465.         val = GETN(G_dvifp,command-PUT1+1);
  466.         if (!SkipMode) SetChar(val, command, PassNo);
  467.         break;
  468.  
  469.     case PUT_RULE:
  470.         val = GET4(G_dvifp);
  471.         val2 = GET4(G_dvifp);
  472.         if (Emitting) SetRule(val, val2, FALSE);
  473.         break;
  474.  
  475.     case NOP:
  476.         break;
  477.  
  478.     /* beginning of a page */
  479.     case BOP:
  480.         cpagep = ftell(G_dvifp) - 1;
  481.         for (i=0; i<=9; i++) {
  482.         count[i] = GET4(G_dvifp);
  483.         }
  484.         G_ppagep = GET4(G_dvifp);
  485.  
  486.         G_h = G_v = w = x = y = z = 0;
  487.         G_hh = G_vv = 0;
  488.         sp = 0;
  489.         G_fontptr = NULL;
  490.         G_prevfont = NULL;
  491.  
  492.         if( count[0] < CL_FirstPage || count[0] > CL_LastPage ) {
  493.         /* skip this page */
  494.         SkipMode = TRUE;
  495.         } else {
  496.         SkipMode = FALSE;
  497.         }
  498.  
  499.         Emitting = (PassNo != 0) && !SkipMode;
  500.  
  501.         if( !SkipMode ) {
  502.         if( PassNo == 0) {
  503.             EMIT(G_outfp,"%d @bop0\n", count[0]);
  504. #ifdef STATS
  505.             if( Stats ) {
  506.                 S_ndc0 = S_ndc;
  507.                 S_tnc0 = S_tnc;
  508.                 S_nbpx0 = S_nbpxl;
  509.             }
  510. #endif STATS
  511.             Progress("[%d",count[0]);
  512.         } else {
  513.             EMIT(G_outfp,"%d @bop1\n", count[0]);
  514.         }
  515.         }
  516.         break;
  517.  
  518.     /* end of this page */
  519.     case EOP:
  520.         if( !SkipMode ) {
  521.         if( PassNo == 0 ) {
  522.             /* start second pass on current page */
  523.             fseek(G_dvifp,cpagep,FROM_START);
  524.             PassNo = 1;
  525.         } else {
  526.             /* end of second pass, and of page processing */
  527.             EMITS("@eop\n");
  528. #ifdef STATS
  529.             if( Stats )
  530.             fprintf(stderr," - %d total ch,  %d diff ch,  %d pxl bytes\n",
  531.                 S_tnc-S_tnc0, S_ndc-S_ndc0, S_nbpxl-S_nbpx0);   
  532. #endif STATS
  533.             Progress("] ");
  534.             G_ndone += 1;
  535.             if ((G_ndone % 10) == 0) Progress("\n");
  536.             PassNo = 0;
  537.         }
  538.         } else {
  539.         /* just finished pass 1 (second pass) on this page */
  540.         /* next page starts in pass 0 */
  541.         PassNo = 0;
  542.         }
  543.         if( PassNo == 0 && CL_Reverse ) { 
  544.         /* go back to previous page, or done */
  545.         if( G_ppagep > 0 ) {
  546.             fseek(G_dvifp, G_ppagep, FROM_START);
  547.         } else {
  548.             AllDone();
  549.         }
  550.         }
  551.         break;
  552.  
  553.     case PUSH:
  554.         if (sp >= STACKSIZE)
  555.         Fatal("stack overflow");
  556.         stack[sp].h = G_h;
  557.         stack[sp].v = G_v;
  558.         stack[sp].w = w;
  559.         stack[sp].x = x;
  560.         stack[sp].y = y;
  561.         stack[sp].z = z;
  562.         sp++;
  563.         break;
  564.  
  565.     case POP:
  566.         --sp;
  567.         if (sp < 0)
  568.         Fatal("stack underflow");
  569.         G_h = stack[sp].h;
  570.         G_v = stack[sp].v;
  571.         w = stack[sp].w;
  572.         x = stack[sp].x;
  573.         y = stack[sp].y;
  574.         z = stack[sp].z;
  575.         break;
  576.  
  577.     case RIGHT1:case RIGHT2:case RIGHT3:case RIGHT4:
  578.         val = GETSN(G_dvifp,command-RIGHT1+1);
  579.         if (Emitting) MoveOver(val);
  580.         break;
  581.  
  582.     /* move right with the w-reg value */
  583.     case W0:
  584.         if (Emitting) MoveOver(w);
  585.         break;
  586.  
  587.     case W1:case W2:case W3:case W4:
  588.         w = GETSN(G_dvifp,command-W1+1);
  589.         if (Emitting) MoveOver(w);
  590.         break;
  591.  
  592.     /* move right with the x-reg value */
  593.     case X0:
  594.         if (Emitting) MoveOver(x);
  595.         break;
  596.  
  597.     case X1:case X2:case X3:case X4:
  598.         x = GETSN(G_dvifp,command-X1+1);
  599.         if (Emitting) MoveOver(x);
  600.         break;
  601.  
  602.     case DOWN1:case DOWN2:case DOWN3:case DOWN4:
  603.         val = GETSN(G_dvifp,command-DOWN1+1);
  604.         if (Emitting) MoveDown(val);
  605.         break;
  606.  
  607.     /* move down with the y-reg value */
  608.     case Y0:
  609.         if (Emitting) MoveDown(y);
  610.         break;
  611.  
  612.     case Y1:case Y2:case Y3:case Y4:
  613.         y = GETSN(G_dvifp,command-Y1+1);
  614.         if (Emitting) MoveDown(y);
  615.         break;
  616.  
  617.     /* move down with the z-reg value */
  618.     case Z0:
  619.         if (Emitting) MoveDown(z);
  620.         break;
  621.  
  622.     case Z1:case Z2:case Z3:case Z4:
  623.         z = GETSN(G_dvifp,command-Z1+1);
  624.         if (Emitting) MoveDown(z);
  625.         break;
  626.  
  627.     case FNT1:case FNT2:case FNT3:case FNT4:
  628.         if (!SkipMode) {
  629.         SetFontNum(GETN(G_dvifp,command-FNT1+1), Emitting);
  630.         }
  631.         break;
  632.  
  633.     case XXX1:case XXX2:case XXX3:case XXX4:
  634.         /* get the special string from the dvi file */
  635.         k = GETN(G_dvifp,command-XXX1+1);
  636.         GetBytes(G_dvifp, SpecialStr, k);
  637.         if (Emitting) DoSpecial(SpecialStr, k);
  638.         break;
  639.  
  640.     case FNT_DEF1:case FNT_DEF2:case FNT_DEF3:case FNT_DEF4:
  641.         k = GETN(G_dvifp, command-FNT_DEF1+1);
  642.         if (CL_PreLoad || HasBeenRead(k)) {
  643.         SkipFontDef();
  644.         } else {
  645.         ReadFontDef(k);
  646.         }
  647.         break;
  648.  
  649.     case PRE:
  650.         Fatal("PRE occurs within file\n");
  651.         break;
  652.  
  653.     case POST:
  654.         if (CL_Reverse) {
  655.         Warning("internal - unexpected POST in dvi file\n");
  656.         }
  657.         AllDone();
  658.         break;
  659.  
  660.     case POST_POST:
  661.         Fatal("POST_POST with no preceding POST\n");
  662.         break;
  663.  
  664.     default:
  665.         if (command >= FONT_00 && command <= FONT_63) {
  666.         if (!SkipMode) SetFontNum(command - FONT_00, Emitting);
  667.         } else if (command >= SETC_000 && command <= SETC_127) {
  668.         if (!SkipMode) SetString(command, PassNo);
  669.         } else {
  670.         Fatal("%d is an undefined DVI command\n", command);
  671.         }
  672.         break;
  673.     }
  674. }
  675.  
  676. /*-->ActualFactor*/
  677. /**********************************************************************/
  678. /**************************  ActualFactor  ****************************/
  679. /**********************************************************************/
  680.  
  681. float        /* compute the actual size factor given the approximation */
  682. ActualFactor(unmodsize)
  683. int unmodsize;        /* actually factor * 1000 */
  684. {
  685.     float realsize;    /* the actual magnification factor */
  686.  
  687.     realsize = (float)unmodsize / 1000.0;
  688.     /* a real hack to correct for rounding in some cases--rkf */
  689.     if(unmodsize==1095) realsize = 1.095445;    /*stephalf*/
  690.     else if(unmodsize==1315) realsize=1.314534;    /*stepihalf*/
  691.     else if(unmodsize==1577) realsize=1.577441;    /*stepiihalf*/
  692.     else if(unmodsize==1893) realsize=1.892929;    /*stepiiihalf*/
  693.     else if(unmodsize==2074) realsize=2.0736;    /*stepiv*/
  694.     else if(unmodsize==2488) realsize=2.48832;  /*stepv*/
  695.     else if(unmodsize==2986) realsize=2.985984;    /*stepiv*/
  696.     /* the remaining magnification steps are represented with sufficient
  697.        accuracy already */
  698.     return(realsize);
  699. }
  700.  
  701.  
  702. /*-->AllDone*/
  703. /**********************************************************************/
  704. /****************************** AllDone  ******************************/
  705. /**********************************************************************/
  706.  
  707. void
  708. AllDone()
  709. {
  710.     register struct font_entry *p;
  711.  
  712.     EMITS("@end\n");
  713.     Progress("\n");
  714.  
  715. #ifdef CREOPT
  716.     if( G_create ) {
  717.     fclose(G_outfp);
  718.     Progress("Output written on \"%s\"\n", G_outfname);
  719.     }
  720. #endif CREOPT
  721.  
  722. #ifdef STATS
  723.     if (Stats) {
  724.     fprintf(stderr,"Total-chars   diff-chars bitmap-bytes #open #close\n");
  725.     fprintf(stderr,"       #   %%       #   %%       #   %%\n");
  726.     fprintf(stderr,"-------- ---  ------ ---  ------ ---  ----- ------\n");
  727.     for (p = G_hfontptr; p != NULL; p = p->next) {
  728.         fprintf(stderr,"%8d%4d",p->ncts,(100*p->ncts + S_tnc/2)/S_tnc);
  729.         fprintf(stderr,"%8d%4d",p->ncdl,(100*p->ncdl + S_ndc/2)/S_ndc);
  730.         fprintf(stderr,"%8d%4d",p->nbpxl,(100*p->nbpxl + S_nbpxl/2)/S_nbpxl);
  731.         fprintf(stderr,"  %5d %5d",p->nopen,p->nclose);
  732.         fprintf(stderr,"  %s\n",p->psname);
  733.     }
  734.     fprintf(stderr,"\nTotal number of characters typeset: %d\n",S_tnc);
  735.     fprintf(stderr,"Number of different characters downloaded: %d\n",S_ndc);
  736.     fprintf(stderr,"Number of bytes of bitmap data downloaded: %d\n",S_nbpxl);
  737.     fprintf(stderr,"Optimal # of bytes of bitmap data: %d\n",S_onbpx);
  738.     }
  739. #endif STATS
  740.  
  741.     if (G_logging) {
  742.     if (G_logfp == NULL) {
  743.         Fatal("missing log file\n");
  744.     }
  745.     fclose(G_logfp);
  746.     Progress("Log file created\n");
  747.     }
  748.  
  749.     exit(G_errenc);
  750. }
  751.  
  752.  
  753. /*-->ChkOpt*/   /* check a user supplied option for validity */
  754. /*********************************************************************/
  755. /****************************** ChkOpt *******************************/
  756. /*********************************************************************/
  757.  
  758. #define ISOPT(s) if( EQ(str,s) ) return( TRUE )
  759.  
  760. int
  761. ChkOpt( str )
  762. char    *str;
  763. {
  764. /*    lcase(str);  doesn't work */
  765.  
  766.     ISOPT("note");      /* its a shame to build this into the program */
  767.     ISOPT("letter");
  768.     ISOPT("legal");
  769.     ISOPT("landscape");
  770.     ISOPT("manualfeed");
  771.     return( FALSE );
  772. }
  773.  
  774.  
  775. /*-->CopyFile*/
  776. /*********************************************************************/
  777. /***************************** CopyFile ******************************/
  778. /*********************************************************************/
  779. /* copy a file straight through to output */
  780.  
  781. void
  782. CopyFile(filename)
  783.     char *filename;
  784. {
  785.     register FILE *spfp;
  786.     register int ch;
  787.  
  788.     if( (spfp=fopen(filename,"r")) == NULL ) {
  789.         Warning("Unable to open file %s\n", filename );
  790.         return;
  791.     }
  792.     Progress("[%s", filename);
  793.     while ((ch = getc(spfp)) != EOF) {
  794.         EMITC(ch);
  795.     }          
  796.     fclose(spfp);
  797.     Progress("] ");
  798. }
  799.  
  800.  
  801. /*-->DecodeArgs*/
  802. /*********************************************************************/
  803. /***************************** DecodeArgs ****************************/
  804. /*********************************************************************/
  805. /* this is a pretty brain-damaged command line processor */
  806. /* but good enough for now */
  807.  
  808. void
  809. DecodeArgs( argc, argv )
  810.     int argc;
  811.     char *argv[];
  812. {
  813.     int argind;            /* argument index for flags */
  814.     char curarea[STRSIZE];    /* current file area */
  815.     char curname[STRSIZE];    /* current file name */
  816.     register char *tcp;        /* temporary character pointer */
  817.     register char *tcp1;    /* temporary character pointer */
  818.  
  819.  
  820.     /* now process command line arguments */
  821.     argind = 1;
  822.     while (argind < argc) {
  823.     tcp = argv[argind];
  824.     if (*tcp == '-') {
  825.         /* this is a command line option, which one? */
  826.         switch(*++tcp) {
  827.  
  828.         case 'a':       /* a selects different font area */
  829.             if( ++argind >= argc ) Fatal("No argument following -a\n");
  830.             if (!access(argv[argind],F_OK)) {
  831.             if (G_fontpathsize < PATHSIZE-1) {
  832.                 if (G_fontpathsize < 1) Fatal("internal - bad font path\n");
  833.                 G_fontpath[G_fontpathsize-1] = argv[argind];
  834.                 G_fontpath[G_fontpathsize] = FONTAREA;
  835.                 G_fontpathsize += 1;
  836.             }
  837.             } else {
  838.             Warning("cannot access font directory %s\n",argv[argind]);
  839.             }
  840.             break;
  841.         case 'F':       /* F selects different font area */
  842.             if( ++argind >= argc ) Fatal("No argument following -F\n");
  843.             if (!access(argv[argind],F_OK)) {
  844.             if (G_fontpathsize < PATHSIZE-1) {
  845.                 if (G_fontpathsize < 1) Fatal("internal - bad font path\n");
  846.                 G_fontpath[G_fontpathsize-1] = argv[argind];
  847.                 G_fontpath[G_fontpathsize] = FONTAREA;
  848.                 G_fontpathsize += 1;
  849.             }
  850.             } else {
  851.             Warning("cannot access font directory %s\n",argv[argind]);
  852.             }
  853.             break;
  854. #ifdef CREOPT
  855.         case 'c':       /* create an output file in spool area */
  856.             G_create = TRUE;
  857.             break;
  858. #endif CREOPT
  859. #ifdef DEBUG
  860.         case 'd':    /* d selects Debug output */
  861.             Debug = TRUE;
  862.             break;
  863. #endif DEBUG
  864.         case 'f':       /* next arg is starting pagenumber */
  865.             if( ++argind >= argc || sscanf(argv[argind], "%d", &CL_FirstPage) != 1 )
  866.             Fatal("Argument to -f is not a valid integer\n", 0);
  867.             break;
  868.  
  869.         case 'h':       /* don't copy PostScript header file through to output */
  870.             CL_header = FALSE;
  871.             break;
  872.  
  873.         case 'i':       /* next arg is a PostScript file to copy */
  874.             if( ++argind >= argc ) Fatal("No argument following -i\n");
  875.             CL_Ifile[CL_nif++] = argv[argind];
  876.             break;
  877.  
  878.         case 'l':    /* enable logging into a log file */
  879.             G_logging = TRUE;
  880.             break;
  881. #ifdef USEGLOBALMAG
  882.         case 'm':       /* specify magnification to use */
  883.             switch (*++tcp) {
  884.  
  885.             case '\0':       /* next arg is a magnification to use */
  886.             if (++argind >= argc || sscanf(argv[argind], "%d", &CL_usermag) != 1)
  887.                 Fatal("Argument to -m is not a valid integer\n", 0);
  888.             break; 
  889.             case '0': CL_usermag = 1000; break;
  890.             case 'h': CL_usermag = 1095; break;
  891.             case '1': CL_usermag = 1200; break;
  892.             case '2': CL_usermag = 1440; break;
  893.             case '3': CL_usermag = 1728; break;
  894.             case '4': CL_usermag = 2074; break;
  895.             case '5': CL_usermag = 2488; break;
  896.             default: Fatal("%c is a bad mag step\n", *tcp);
  897.             }
  898.             break;
  899. #endif USEGLOBALMAG
  900.         case 'n':       /* next arg is number of copies to print */
  901.             if( ++argind >= argc || sscanf(argv[argind], "%d", &CL_ncopies) != 1 )
  902.             Fatal("Argument to -n is not a valid integer\n", 0);
  903.             break;    
  904.  
  905.         case 'o':       /* next arg is a PostScript command to send */
  906.             if( ++argind >= argc )
  907.             Fatal("No argument following -o\n", 0);
  908.             CL_PScmd[CL_nps++] = argv[argind];
  909.             break;
  910.  
  911.         case 'p':    /* p prohibits pre-font loading */
  912.             CL_PreLoad = 0;
  913.             CL_Reverse = FALSE;    /* must then process in forward order */
  914.             break;
  915.  
  916.         case 'q':       /* quiet operation */
  917.             G_quiet = TRUE;
  918.             break;
  919.  
  920.         case 'r':       /* don't process pages in reverse order */
  921.             CL_Reverse = FALSE;
  922.             break;
  923. #ifdef STATS
  924.         case 's':       /* print some statistics */
  925.             Stats = TRUE;
  926.             break;
  927. #endif STATS
  928.         case 't':       /* next arg is ending pagenumber */
  929.             if( ++argind >= argc || sscanf(argv[argind], "%d", &CL_LastPage) != 1 )
  930.             Fatal("Argument to -t is not a valid integer\n", 0);
  931.             break;
  932.  
  933.         case 'w':       /* don't print out warnings */
  934.             G_nowarn = TRUE;
  935.             break;
  936.  
  937.         default:
  938.             Warning("%c is not a legal flag\n", *tcp);
  939.         }
  940.     } else {
  941.         /* this is not a command line option, must be the dvi file name */
  942.         if (G_dvifp != NULL) {
  943.         Warning("more than one dvi input file - ignoring \"%s\"\n",
  944.                 G_filename);
  945.         fclose(G_dvifp);
  946.         }
  947.         /* split into directory + file name */
  948.         tcp = rindex(argv[argind], '/');
  949.         /* store the directory name */
  950.         if (tcp == NULL)  {
  951.         curarea[0] = '\0';
  952.         tcp = argv[argind];
  953.         } else  {
  954.         strcpy(curarea, argv[argind]);
  955.         curarea[tcp-argv[argind]+1] = '\0';
  956.         tcp += 1;
  957.         }
  958.     
  959.         /* store the file name */
  960.         strcpy(curname, tcp);
  961.  
  962.         /* split into file name + extension */
  963.         tcp1 = rindex(tcp, '.');
  964.         if (tcp1 == NULL) {
  965.         strcpy(G_rootname, curname);
  966.         strcat(curname, ".dvi");
  967.         } else {
  968.         *tcp1 = '\0';
  969.         strcpy(G_rootname, curname);
  970.         *tcp1 = '.';
  971.         }
  972.     
  973.         /* store the full path name */
  974.         strcpy(G_filename, curarea);
  975.         strcat(G_filename, curname);
  976.     
  977.         /* open the dvi input file */
  978.         if ((G_dvifp=BINARYOPEN(G_filename,"r")) == NULL)  {
  979.         Fatal("can't open DVI file \"%s\"\n", G_filename);
  980.         }
  981.     
  982.         if (G_logging) {
  983.         strcpy(G_Logname, curname);
  984.         strcat(G_Logname, ".log");
  985.         if ((G_logfp=BINARYOPEN(G_Logname,"w+")) == NULL)  {
  986.             Fatal("can't open log file \"%s\"\n", G_Logname);
  987.         }
  988.         }
  989.     }
  990.     argind++;
  991.     }
  992.  
  993.     /* check that we got an input file to process */
  994.     if (G_dvifp == NULL)  {
  995.     Fatal("usage: %s [-a area] [-c] [-h] [-o option] [-p] [-s] [-r] [-f n] [-t n] [-m{0|h|1|2|3|4| mag}] [-a fontarea] dvifile\n\n", 
  996.         G_progname);
  997.     }
  998.  
  999.     /* now check the environment for default values */
  1000.     /* check for font area (directory/path) */
  1001.     if ((tcp = getenv(ENVTEXFONTS)) != (char *)NULL) {
  1002.     /* split out the path name components */
  1003.     /* note this code modifies the string returned by getenv() */
  1004.     while ((tcp1 = index(tcp,':')) != 0) {
  1005.         *tcp1 = '\0';
  1006.         if ((tcp == tcp1) || (*tcp == NULL)) {
  1007.         Warning("null entry in font path environment variable\n");
  1008.         continue;
  1009.         }
  1010.         if (access(tcp,F_OK)) {
  1011.         Warning("cannot access font directory %s\n",tcp);
  1012.         continue;
  1013.         }
  1014.         if (G_fontpathsize < PATHSIZE-1) {
  1015.         if (G_fontpathsize < 1) Fatal("internal - bad font path\n");
  1016.         G_fontpath[G_fontpathsize-1] = tcp;
  1017.         G_fontpathsize += 1;
  1018.         } else {
  1019.         Warning("too many entries in font path environment variable, ignoring %s\n",tcp);
  1020.         }
  1021.         tcp = tcp1 + 1;
  1022.     }
  1023.     if ((tcp == tcp1) || (*tcp == NULL)) {
  1024.         Warning("null entry in font path environment variable\n");
  1025.     } else if (access(tcp,F_OK)) {
  1026.         Warning("cannot access font directory %s\n",tcp);
  1027.     } else {
  1028.         if (G_fontpathsize < PATHSIZE-1) {
  1029.         if (G_fontpathsize < 1) Fatal("internal - bad font path\n");
  1030.         G_fontpath[G_fontpathsize-1] = tcp;
  1031.         G_fontpathsize += 1;
  1032.         } else {
  1033.         Warning("too many entries in font path environment variable, ignoring %s\n",tcp);
  1034.         }
  1035.     }
  1036.     G_fontpath[G_fontpathsize-1] = FONTAREA;
  1037.     }
  1038. }
  1039.  
  1040.  
  1041. /*-->DoConv*/
  1042. /*********************************************************************/
  1043. /********************************  DoConv  ***************************/
  1044. /*********************************************************************/
  1045.  
  1046. int DoConv(num, den, convResolution)
  1047. {
  1048.     register float conv;
  1049.     conv = ((float)num/(float)den) * 
  1050. #ifdef USEGLOBALMAG
  1051. /*    ActualFactor(D_mag) * why was this in as Actual Factor?  jls */
  1052.     ((float) D_mag/1000.0) *
  1053. #endif USEGLOBALMAG
  1054.     ((float)convResolution/254000.0);
  1055.     return((int) (1.0 / conv + 0.5));
  1056. }
  1057.  
  1058.  
  1059. /*-->DoSpecial*/
  1060. /*********************************************************************/
  1061. /*****************************  DoSpecial  ***************************/
  1062. /*********************************************************************/
  1063.  
  1064. typedef enum {None, String, Integer, Number, Dimension} ValTyp;
  1065.  
  1066. typedef struct {
  1067.     char    *Key;       /* the keyword string */
  1068.     char    *Val;       /* the value string */
  1069.     ValTyp  vt;         /* the value type */
  1070.     union {     /* the decoded value */
  1071.         int  i;
  1072.         float n;
  1073.         } v;
  1074.     } KeyWord;
  1075.  
  1076. typedef struct {
  1077.     char    *Entry;
  1078.     ValTyp  Type;
  1079.     } KeyDesc;
  1080.  
  1081. #define PSFILE 0
  1082. KeyDesc KeyTab[] = {{"psfile", String},
  1083.             {"hsize", Dimension},
  1084.             {"vsize", Dimension},
  1085.             {"hoffset", Dimension},
  1086.             {"voffset", Dimension},
  1087.             {"hscale", Number},
  1088.             {"vscale", Number}};
  1089.  
  1090. #define NKEYS (sizeof(KeyTab)/sizeof(KeyTab[0]))
  1091.  
  1092. /*-->DoSpecial*/
  1093. /*********************************************************************/
  1094. /*****************************  DoSpecial  ***************************/
  1095. /*********************************************************************/
  1096. /* interpret a \special command, made up of keyword=value pairs */
  1097.  
  1098. void
  1099. DoSpecial( str, n )
  1100.     char    *str;
  1101.     int n;
  1102. { 
  1103.     char spbuf[STRSIZE]; 
  1104.     char *sf = NULL;
  1105.     KeyWord k;
  1106.     int i;
  1107.  
  1108.     str[n] = '\0';
  1109.     spbuf[0] = '\0';
  1110.  
  1111.     SetPosn(G_h, G_v);
  1112.     EMITS("@beginspecial\n");
  1113.  
  1114.     /* get all keyword-value pairs */
  1115.     while( (str=GetKeyStr(str,&k)) != NULL ) {
  1116.     /* for compatibility, single words are taken as file names */
  1117.     if( k.vt == None && access(k.Key,F_OK) == 0) {
  1118.         if (sf) {
  1119.         Warning("More than one \\special file name given. %s ignored", sf );
  1120.         }
  1121.         strcpy(spbuf, k.Key);
  1122.         sf = spbuf;
  1123.     } else if( GetKeyVal( &k, KeyTab, NKEYS, &i ) && i != -1 ) {
  1124.         if( i == PSFILE ) {
  1125.         if (sf) {
  1126.             Warning("More than one \\special file name given. %s ignored", sf );
  1127.         }
  1128.         strcpy(spbuf, k.Val);
  1129.         sf = spbuf;
  1130.         } else {
  1131.         /* the keywords are simply output as PS procedure calls */
  1132.         EMIT(G_outfp, "%f @%s\n", k.v.n, KeyTab[i].Entry);
  1133.         }
  1134.     } else {
  1135.         Warning("Invalid keyword or value in \\special - \"%s\" ignored", k.Key );
  1136.     }
  1137.     }
  1138.  
  1139.     EMITS("@setspecial\n");
  1140.  
  1141.     if (sf) {
  1142.     CopyFile( sf );
  1143.     } else {
  1144.     Warning("No special file name provided.");
  1145.     }
  1146.  
  1147.     EMITS("@endspecial\n");
  1148. }
  1149.  
  1150.  
  1151. /*-->EmitCharBitMap*/
  1152. /**********************************************************************/
  1153. /************************  EmitCharBitMap  ****************************/
  1154. /**********************************************************************/
  1155. /* output a character bitmap */
  1156.  
  1157. void
  1158. EmitCharBitMap(ch, ce)
  1159.     int ch;
  1160.     register struct char_entry *ce;
  1161. {
  1162.     register unsigned char *sl;
  1163.     register struct font_entry *fontp;
  1164. #ifdef USEPXL
  1165.     int i;
  1166.     register int j;
  1167.     register int cc;
  1168.     int nbpl, nwpl;
  1169. #else not USEPXL
  1170.     register int cc;
  1171.     register int i;
  1172.     int nbpl;        /* number of bytes per line of bitmap */
  1173. #endif USEPXL
  1174.     float cw;    /* char width, in "dots" */
  1175.             /* we rely on PostScript maintaining sufficient accuracy */
  1176.  
  1177.     /* sanity check */
  1178.     fontp = G_fontptr;
  1179.     if (fontp == NULL) {
  1180.         Fatal("internal - null pointer in EmitCharBitMap()\n");
  1181.     }
  1182.  
  1183.     /* Output in PostScript coord system (y +ive up, x +ive right)
  1184.        (0,0) of char bitmap at lower left.  Output scan lines
  1185.        from bottom to top */
  1186.  
  1187.     /* open font dict before first char */
  1188.     if (fontp->ncdl == 0) {
  1189.         EMIT(G_outfp,"[ %d ] /%s @newfont\n",
  1190.         fontp->font_mag,fontp->psname);
  1191.     }
  1192.  
  1193.     /* because this isn't done on pass 0 */
  1194.     if (fontp != G_prevfont) {
  1195.         EMIT(G_outfp,"%s @sf\n", fontp->psname);
  1196.         G_prevfont = fontp;
  1197.     }
  1198.  
  1199.     /* start the bitmap */
  1200.     EMITS("[<");
  1201.     cc = 2;
  1202.  
  1203. #ifdef USEPXL
  1204.     nbpl = (ce->width + 7) >> 3;
  1205.     nwpl = (ce->width + 31) >> 5;
  1206.     for(i = ce->height-1;  i >= 0;  i--) {
  1207.         sl = (unsigned char *)(ce->where.address.pixptr + i*nwpl);
  1208.         for(j = 0;  j < nbpl;  j++, sl++) {
  1209.             if( cc > 100 ) {
  1210.                 EMITS("\n  ");   cc = 2;
  1211.             }
  1212.             EMITH(*sl);
  1213.             cc += 2;
  1214.         }
  1215.     }
  1216. #else not USEPXL
  1217.     /* assume we just called gf_readbits() */
  1218.     nbpl = (gf_num_cols + 7) >> 3;
  1219.     for(i=0, sl=gf_bits; i<gf_num_bytes; i++, sl++) {
  1220.         if (cc > 100) {
  1221.             EMITS("\n  ");
  1222.             cc = 2;
  1223.         }
  1224.         EMITH(*sl);
  1225.         cc += 2;
  1226.     }
  1227. #endif USEPXL
  1228.  
  1229.     /* compute character width */
  1230.     cw = (float)ce->tfmw / (float)G_hconv;
  1231.  
  1232. #ifdef USEPXL
  1233.     EMIT(G_outfp,"> %d %d %d %d %.3f] %d @dc\n", 
  1234.          nbpl<<3, ce->height, ce->xOffset,
  1235.          (((int)ce->height)-ce->yOffset)-1, cw, ch);
  1236. #else not USEPXL
  1237.     EMIT(G_outfp,"> %d %d %d %d %.3f] %d @dc\n", 
  1238.          nbpl<<3, gf_num_rows, gf_x_offset, gf_y_offset, cw, ch);
  1239. #endif USEPXL
  1240.  
  1241.     /* one more character down loaded */
  1242.     fontp->ncdl += 1;
  1243.  
  1244. #ifdef STATS
  1245. #ifdef USEPXL
  1246.     S_nbpxl += nbpl*ce->height;
  1247.     fontp->nbpxl += nbpl*ce->height;
  1248.     S_onbpx += (ce->width*ce->height + 7) >> 3;
  1249. #else not USEPXL
  1250.     S_nbpxl += nbpl*gf_num_rows;
  1251.     fontp->nbpxl += nbpl*gf_num_rows;
  1252.     S_onbpx += (gf_num_cols*gf_num_rows + 7) >> 3;
  1253. #endif USEPXL
  1254.     S_ndc += 1;
  1255. #endif STATS
  1256. }
  1257.  
  1258. /*-->Fatal*/
  1259. /**********************************************************************/
  1260. /******************************  Fatal  *******************************/
  1261. /**********************************************************************/
  1262. /* emit a message and die */
  1263. /* VARARGS1 for lint */
  1264.  
  1265. void
  1266. Fatal(fmt, a, b, c, d, e, f)        /* issue a fatal error message */
  1267.     char *fmt;                /* format */
  1268.     char *a, *b, *c, *d, *e, *f;    /* arguments */
  1269. {
  1270.     /* always print fatal error message */
  1271.     fprintf(stderr, "\n%s: FATAL--", G_progname);
  1272.     fprintf(stderr, fmt, a, b, c, d, e, f);
  1273.     fprintf(stderr, "\n");
  1274.  
  1275.     /* if logging to a file, print again there */
  1276.     if (G_logging) {
  1277.     if (G_logfp == NULL) {
  1278.         fprintf(stderr,"\n%s: FATAL--missing log file\n",G_progname);
  1279.     }
  1280.     fprintf(G_logfp, "\n%s: FATAL--", G_progname);
  1281.     fprintf(G_logfp, fmt, a, b, c, d, e, f);
  1282.     fprintf(G_logfp, "\n");
  1283.     }
  1284.  
  1285. #ifdef CREOPT
  1286.     /* close and delete the output file */
  1287.     if (G_create && G_outfp != NULL) {
  1288.     fclose(G_outfp);
  1289.     unlink(G_outfname);
  1290.     }
  1291. #endif CREOPT
  1292.     exit(1);
  1293. }
  1294.  
  1295. /*-->GetBytes*/
  1296. /**********************************************************************/
  1297. /*****************************  GetBytes  *****************************/
  1298. /**********************************************************************/
  1299. /* get n bytes from file fp, store string in cp */
  1300.  
  1301. void
  1302. GetBytes(fp, cp, n)
  1303.     register FILE *fp;    /* file pointer     */
  1304.     register char *cp;    /* character pointer */
  1305.     register int n;    /* number of bytes  */
  1306. {
  1307.     while (n--) {
  1308.     *cp++ = getc(fp);
  1309.     }
  1310. }
  1311.  
  1312. /*-->GetKeyStr*/
  1313. /**********************************************************************/
  1314. /*****************************  GetKeyStr  ****************************/
  1315. /**********************************************************************/
  1316.  
  1317.     /* extract first keyword-value pair from string (value part may be null)
  1318.      * return pointer to remainder of string
  1319.      * return NULL if none found
  1320.      */
  1321.  
  1322. char    KeyStr[STRSIZE];
  1323. char    ValStr[STRSIZE];
  1324.  
  1325. char *GetKeyStr( str, kw )
  1326. char    *str;
  1327. KeyWord *kw;
  1328. {
  1329.     char *s, *k, *v, t;
  1330.  
  1331.     if( !str ) return( NULL );
  1332.  
  1333.     for( s=str; *s == ' '; s++ ) ;      /* skip over blanks */
  1334.     if( *s == '\0' ) return( NULL );
  1335.  
  1336.     for( k=KeyStr;      /* extract keyword portion */
  1337.          *s != ' ' && *s != '\0' && *s != '='; 
  1338.          *k++ = *s++ ) ;
  1339.     *k = '\0';
  1340.     kw->Key = KeyStr;
  1341.     kw->Val = v = NULL;
  1342.     kw->vt = None;
  1343.  
  1344.     for( ; *s == ' '; s++ ) ;           /* skip over blanks */
  1345.     if( *s != '=' )     /* look for "=" */
  1346.         return( s );
  1347.  
  1348.     for( s++ ; *s == ' '; s++ ) ;       /* skip over blanks */
  1349.     if( *s == '\'' || *s == '\"' )      /* get string delimiter */
  1350.         t = *s++;
  1351.     else
  1352.         t = ' ';
  1353.     for( v=ValStr;      /* copy value portion up to delim */
  1354.          *s != t && *s != '\0';
  1355.          *v++ = *s++ ) ;
  1356.     if( t != ' ' && *s == t ) s++;
  1357.     *v = '\0';
  1358.     kw->Val = ValStr;
  1359.     kw->vt = String;
  1360.  
  1361.     return( s );
  1362. }
  1363.  
  1364. /*-->GetKeyVal*/
  1365. /**********************************************************************/
  1366. /*****************************  GetKeyVal  ****************************/
  1367. /**********************************************************************/
  1368.  
  1369.     /* get next keyword-value pair
  1370.      * decode value according to table entry
  1371.      */
  1372.  
  1373. int GetKeyVal( kw, tab, nt, tno)
  1374. KeyWord *kw; 
  1375. KeyDesc tab[];
  1376. int     nt;
  1377. int     *tno;
  1378. {
  1379.     int i;
  1380.     char c = '\0';
  1381.  
  1382.     *tno = -1;
  1383.  
  1384.     for(i=0; i<nt; i++)
  1385.         if( IsSame(kw->Key, tab[i].Entry) ) {
  1386.             *tno = i;
  1387.             switch( tab[i].Type ) {
  1388.                 case None: 
  1389.                     if( kw->vt != None ) return( FALSE );
  1390.                     break;
  1391.                 case String:
  1392.                     if( kw->vt != String ) return( FALSE );
  1393.                     break;
  1394.                 case Integer:
  1395.                     if( kw->vt != String ) return( FALSE );
  1396.                     if( sscanf(kw->Val,"%d%c", &(kw->v.i), &c) != 1
  1397.                         || c != '\0' ) return( FALSE );
  1398.                     break;
  1399.                 case Number:
  1400.                 case Dimension:
  1401.                     if( kw->vt != String ) return( FALSE );
  1402.                     if( sscanf(kw->Val,"%f%c", &(kw->v.n), &c) != 1
  1403.                         || c != '\0' ) return( FALSE );
  1404.                     break;
  1405.                 }
  1406.             kw->vt = tab[i].Type;
  1407.             return( TRUE );
  1408.             }
  1409.  
  1410.     return( TRUE );
  1411. }
  1412.  
  1413. /*-->HasBeenRead*/
  1414. /**********************************************************************/
  1415. /***************************  HasBeenRead  ****************************/
  1416. /**********************************************************************/
  1417.  
  1418. int
  1419. HasBeenRead(fontnum)
  1420.     int fontnum;
  1421. {
  1422.     register struct font_entry *ptr;
  1423.  
  1424.     /* search font entry list for this font number (from dvi file) */
  1425.     ptr = G_hfontptr;
  1426.     while ((ptr != NULL) && (ptr->dvi_fnum != fontnum)) {
  1427.     ptr = ptr->next;
  1428.     }
  1429.     return( ptr != NULL );
  1430. }
  1431.  
  1432. /*-->IsSame*/
  1433. /**********************************************************************/
  1434. /*******************************  IsSame  *****************************/
  1435. /**********************************************************************/
  1436. /* compare strings, ignore case */
  1437.  
  1438. int IsSame(a, b)
  1439. char *a, *b;
  1440. {
  1441.     for( ; *a != '\0'; ) {
  1442.         if( tolower(*a++) != tolower(*b++) ) return( FALSE );
  1443.     }
  1444.     return( *a == *b ? TRUE : FALSE );
  1445. }
  1446.  
  1447. /*-->MoveDown*/
  1448. /**********************************************************************/
  1449. /****************************  MoveDown  ******************************/
  1450. /**********************************************************************/
  1451.  
  1452. #ifndef MACROS
  1453. void
  1454. MoveDown(a)
  1455. int a;
  1456. {
  1457.     G_v += a;
  1458. }
  1459. #endif MACROS
  1460.  
  1461. /*-->MoveOver*/
  1462. /**********************************************************************/
  1463. /****************************  MoveOver  ******************************/
  1464. /**********************************************************************/
  1465.  
  1466. #ifndef MACROS
  1467. void
  1468. MoveOver(b)
  1469. int b;
  1470. {
  1471.     G_h += b;
  1472. }
  1473. #endif MACROS
  1474.  
  1475. /*-->NoSignExtend*/
  1476. /**********************************************************************/
  1477. /***************************  NoSignExtend  ***************************/
  1478. /**********************************************************************/
  1479.  
  1480. int
  1481. NoSignExtend(fp, n)    /* return n byte quantity from file fd */
  1482. register FILE *fp;    /* file pointer    */
  1483. register int n;        /* number of bytes */
  1484.  
  1485. {
  1486.     register int x;    /* number being constructed */
  1487.  
  1488.     x = 0;
  1489.     while (n--)  {
  1490.     x <<= 8;
  1491.     x |= getc(fp);
  1492.     }
  1493.     return(x);
  1494. }
  1495.  
  1496. /*-->OpenFontFile*/
  1497. /**********************************************************************/
  1498. /************************** OpenFontFile  *****************************/
  1499. /**********************************************************************/
  1500. /***********************************************************************
  1501.     The original version of this dvi driver reopened the font file  each
  1502.     time the font changed, resulting in an enormous number of relatively
  1503.     expensive file  openings.   This version  keeps  a cache  of  up  to
  1504.     MAXOPEN open files,  so that when  a font change  is made, the  file
  1505.     pointer, G_fontfp, can  usually be  updated from the  cache.  When  the
  1506.     file is not found in  the cache, it must  be opened.  In this  case,
  1507.     the next empty slot  in the cache  is assigned, or  if the cache  is
  1508.     full, the least used font file is closed and its slot reassigned for
  1509.     the new file.  Identification of the least used file is based on the
  1510.     counts of the number  of times each file  has been "opened" by  this
  1511.     routine.  On return, the file pointer is always repositioned to  the
  1512.     beginning of the file.
  1513.  
  1514. ***********************************************************************/
  1515.  
  1516. void
  1517. OpenFontFile()
  1518. {
  1519.     register struct font_entry *fontp;
  1520.     register struct open_font_list *openp;
  1521.     register struct font_entry *least_fontp;
  1522.     register struct open_font_list *least_openp;
  1523.     register FILE *fid;
  1524.  
  1525.  
  1526. #ifdef DEBUG
  1527.     if (Debug) printf("Open Font file\n");
  1528. #endif DEBUG
  1529.     /* check for consistency here */
  1530.     if (G_fontptr == NULL) {
  1531.     Fatal("internal - null font structure pointer in OpenFontFile()\n");
  1532.     }
  1533.  
  1534. #ifdef STATS
  1535.     /* count number of times open attempted */
  1536.     G_fontptr->nopen += 1;
  1537. #endif STATS
  1538.  
  1539.     /* G_pfontptr is last font "OpenFontFile"'ed */
  1540.     if (G_pfontptr == G_fontptr) {
  1541.     /* we need not have been called */
  1542.     return;
  1543.     }
  1544.  
  1545.     /* check if this font file is already open */
  1546.     fontp = G_fontptr;
  1547.     if ((openp = fontp->open_font_ptr) == NULL) {
  1548.     /* this file is not open, so open it */
  1549.     if (G_nopen < MAXOPEN-1) {
  1550.         /* still open slots, so use one */
  1551.         openp = &G_font_files[G_nopen];
  1552.         G_nopen += 1;
  1553. #ifdef DEBUG
  1554.         if (Debug) fprintf(stderr,"opening (new slot) font file %s\n",fontp->name);
  1555. #endif DEBUG
  1556.     } else {
  1557. #ifdef DEBUG
  1558.         if (Debug) fprintf(stderr,"opening (find slot) font file %s\n",fontp->name);
  1559. #endif DEBUG
  1560.         /* find least used, close it, and reuse slot */
  1561.         /* list full -- find least used file, */
  1562.         /* close it, and reuse slot for new file */
  1563.         least_openp = &G_font_files[0];
  1564.         for (openp = &G_font_files[G_nopen-1]; openp > &G_font_files[0]; openp -= 1) {
  1565.         if (least_openp->use_count > openp->use_count) least_openp = openp;
  1566.         }
  1567.         openp = least_openp;
  1568.         if (openp->pixel_file_id != NO_FILE) {
  1569.         fid = openp->pixel_file_id;
  1570.         if ((least_fontp = openp->font_entry_ptr) == NULL) {
  1571.             Fatal("internal - bad open font in OpenFontFile()\n");
  1572.         }
  1573.         /* mark as closed */
  1574.         least_fontp->font_file_id = NULL;
  1575.         least_fontp->open_font_ptr = NULL;
  1576. #ifdef STATS
  1577.         /* count number of times open attempted */
  1578.         G_fontptr->nclose += 1;
  1579.         if (Stats) fprintf(stderr,"closed font file %s\n",least_fontp->name);
  1580. #endif STATS
  1581.         fclose( fid );
  1582.  
  1583.         }
  1584.     }
  1585.     if ((G_fontfp=BINARYOPEN(fontp->name,"r")) == NULL) {
  1586.         Warning("cannot open font file %s\n",fontp->name);
  1587.         G_fontfp = NO_FILE;
  1588.     }
  1589. #ifdef STATS
  1590.     else {
  1591.         if (Stats) fprintf(stderr,"opened font file %s\n",fontp->name);
  1592.     }
  1593. #endif STATS
  1594.     /* initialize this entry in open font file list */
  1595.     openp->pixel_file_id = G_fontfp;
  1596.     openp->font_entry_ptr = fontp;
  1597.     openp->use_count = 0;
  1598.     fontp->font_file_id = G_fontfp;    /* set file identifier */
  1599.     fontp->open_font_ptr = openp;    /* open file id */
  1600.     } else {
  1601.     /* this file is already open */
  1602.     if ((G_fontfp = openp->pixel_file_id) != NO_FILE) {
  1603.         /* is this necessary? */
  1604.         /* reposition to start of file */
  1605.         fseek(G_fontfp,(long)0,FROM_START);
  1606.     } else {
  1607.         Warning("internal - bad font file pointer - OpenFontFile()\n");
  1608.     }
  1609.     }
  1610.  
  1611.     /* have a new font file */
  1612.     G_fontptr = fontp;
  1613.     G_pfontptr = fontp;            /* make previous = current font */
  1614.     openp->use_count += 1;        /* update reference count */
  1615. #ifndef USEPXL
  1616.     gf_infile = G_fontfp;            /* used in gf reader */
  1617.     gf_filename = G_fontptr->name;        /* used in gf reader */
  1618. #endif USEPXL
  1619. }
  1620.  
  1621. #ifdef CREOPT
  1622. /*-->OpenOutput*/
  1623. /**********************************************************************/
  1624. /*************************** OpenOutput *******************************/
  1625. /**********************************************************************/
  1626. /* generate a unique file name and open it */
  1627. /* this is only for creating spool files, not general output files */
  1628.  
  1629. FILE*
  1630. OpenOutput()
  1631. {
  1632.     FILE*   fp;
  1633.     long t;
  1634.     int  n = 0;
  1635.     char *p, *pp, b[256];
  1636.     int nd;
  1637.  
  1638.     time( &t );
  1639.     t = t % 100000;
  1640.     strcpy( G_outfname, SPOOLFILE );
  1641.     sprintf( b, "%s.%s.%x", logname(), G_rootname, t );
  1642.     if( (nd=strlen(b)-MAXFLEN) > 0 ) {
  1643.            for(pp=(p=rindex(b,'.')); p && *p != '\0'; *(pp-nd) = *p++, pp++) ;
  1644.            *(pp-nd) = '\0';
  1645.     }
  1646.     strcat( G_outfname, b );
  1647.  
  1648.     while( access(G_outfname,F_OK) == 0 ) {
  1649.         n += 1;
  1650.         if( n > 10 ) 
  1651.             Fatal("Unable to create a unique output file name: %s\n", G_outfname );
  1652.         strcpy( G_outfname, SPOOLFILE );
  1653.         sprintf( b, "%s.%s.%x.%d", logname(), G_rootname, t, n );
  1654.         if( (nd=strlen(b)-MAXFLEN) > 0 ) {
  1655.             for(pp=(p=rindex(b,'.')); p && *p != '\0'; *(pp-nd) = *p++, pp++) ;
  1656.             *(pp-nd) = '\0';
  1657.             }
  1658.         strcat( G_outfname, b );
  1659.         }
  1660.  
  1661.     if( (fp=fopen(G_outfname,"w")) == NULL )
  1662.         Fatal("Unable to create output file: %s\n", G_outfname);
  1663.  
  1664.     return( fp );
  1665. }
  1666. #endif CREOPT
  1667.  
  1668. /*-->PixRound*/
  1669. /**********************************************************************/
  1670. /*****************************  PixRound  *****************************/
  1671. /**********************************************************************/
  1672.  
  1673. #ifndef MACROS
  1674. int
  1675. PixRound(x, conv)    /* return rounded number of pixels */
  1676. register int x;        /* in DVI units     */
  1677. int conv;        /* conversion factor */
  1678. {
  1679.     return((int)((x + (conv >> 1)) / conv));
  1680. }
  1681. #endif MACROS
  1682.  
  1683. /*-->PutInt*/
  1684. /**********************************************************************/
  1685. /*****************************  PutInt  *******************************/
  1686. /**********************************************************************/
  1687. /* output an integer followed by a space */
  1688. /* could we put this number out in hex to make this faster? */
  1689.  
  1690. void
  1691. PutInt(num)
  1692.     register int num;
  1693. {
  1694.     char buf[10];
  1695.     register char *b;
  1696.  
  1697.     if (num == 0) {
  1698.     EMITC('0'); 
  1699.     } else {
  1700.     if (num < 0) {
  1701.         EMITC('-');
  1702.         num = -num;
  1703.     }
  1704.     
  1705.     for (b=buf;  num>0; ) {
  1706.         *b++ = digit[num%10];
  1707.         num /= 10;
  1708.     }
  1709.     
  1710.     while (b>buf) {
  1711.         EMITC(*--b);
  1712.     }
  1713.     }
  1714.  
  1715.     EMITC(' ');
  1716. }
  1717.  
  1718. /*-->PutOct*/
  1719. /**********************************************************************/
  1720. /*****************************  PutOct  *******************************/
  1721. /**********************************************************************/
  1722.  
  1723. void
  1724. PutOct(num)           /* output an 3 digit octal number preceded by a "\" */
  1725. register int num;
  1726. {      
  1727.     EMITC( '\\' ); 
  1728.     EMITC( digit[(num&0300)>>6] );
  1729.     EMITC( digit[(num&0070)>>3] ); 
  1730.     EMITC( digit[num&0007] );
  1731. }
  1732.  
  1733. /*-->GetFontDef*/
  1734. /**********************************************************************/
  1735. /**************************** GetFontDef  *****************************/
  1736. /**********************************************************************/
  1737. /***********************************************************************
  1738.    Read the font  definitions as they  are in the  postamble of the  DVI
  1739.    file.
  1740. ***********************************************************************/
  1741.  
  1742. void
  1743. GetFontDef()
  1744. {
  1745.     register int byte;
  1746.  
  1747.     while (((byte = GET1(G_dvifp)) >= FNT_DEF1) &&
  1748.     (byte <= FNT_DEF4)) {
  1749.     switch (byte) {
  1750.     case FNT_DEF1:
  1751.         ReadFontDef (GET1(G_dvifp));
  1752.         break;
  1753.     case FNT_DEF2:
  1754.         ReadFontDef (GET2(G_dvifp));
  1755.         break;
  1756.     case FNT_DEF3:
  1757.         ReadFontDef (GET3(G_dvifp));
  1758.         break;
  1759.     case FNT_DEF4:
  1760.         ReadFontDef (GET4(G_dvifp));
  1761.         break;
  1762.     default:
  1763.         Fatal ("Bad byte value in font defs - DVI post-amble");
  1764.         break;
  1765.     }
  1766.     }
  1767.     if (byte != POST_POST) {
  1768.     Fatal ("POST_POST missing after font defs - DVI post-amble");
  1769.     }
  1770. }
  1771.  
  1772. /*-->ReadFontDef*/
  1773. /**********************************************************************/
  1774. /****************************  ReadFontDef  ***************************/
  1775. /**********************************************************************/
  1776. /* read a font definition out of the dvi file */
  1777. /* then go find the font file (pxl or gf) */
  1778. /* read a font definition out of the font file (pxl or gf) */
  1779.  
  1780. int
  1781. ReadFontDef(fontnum)
  1782.     int fontnum;        /* font number */
  1783. {
  1784.     int i;
  1785.     register struct font_entry *tfontptr;    /* temp font_entry pointer */
  1786.     register struct char_entry *tcharptr;    /* temp char_entry pointer */
  1787.     int nmag;
  1788.     char nname[STRSIZE];
  1789.  
  1790.     /* check to see if this font has already been read in */
  1791.     /* this was a bug in the last version */
  1792.     /* linear search of font entry list */
  1793.     tfontptr = G_hfontptr;
  1794.     while ((tfontptr != NULL) && (tfontptr->dvi_fnum != fontnum)) {
  1795.     tfontptr = tfontptr->next;
  1796.     }
  1797.     if (tfontptr != NULL) {
  1798.     /* we found this font, already read */
  1799. #ifdef STATS
  1800.     if (Stats) fprintf(stderr,"re-read font file %s\n",tfontptr->name);
  1801. #endif STATS
  1802.     G_fontptr = tfontptr;
  1803.     return;
  1804.     }
  1805.  
  1806.     /* allocate a new font entry */
  1807.     if ((tfontptr = NEW(struct font_entry)) == NULL) {
  1808.     Fatal("can't malloc space for font_entry");
  1809.     }
  1810.  
  1811.     /* link this entry into list (at head) */
  1812.     tfontptr->next = G_hfontptr;
  1813.     G_fontptr = G_hfontptr = tfontptr;
  1814.  
  1815.     /* initialize the new entry */
  1816.     tfontptr->font_file_id = NULL;    /* this font file not open yet */
  1817.     tfontptr->open_font_ptr = NULL;    /* this font file not open yet */
  1818.     tfontptr->ncdl = 0;            /* # chars downloaded */
  1819. #ifdef STATS
  1820.     tfontptr->nbpxl = 0;
  1821.     tfontptr->ncts = 0;
  1822.     tfontptr->nopen = 0;
  1823.     tfontptr->nclose = 0;
  1824. #endif STATS
  1825.  
  1826.     /* get font info from dvi file */
  1827.     tfontptr->dvi_fnum = fontnum;    /* font number */
  1828.     tfontptr->dvi_check = GET4(G_dvifp);    /* checksum */
  1829.     tfontptr->dvi_s = GET4(G_dvifp);    /* space size */
  1830.     tfontptr->dvi_d = GET4(G_dvifp);    /* design size */
  1831.     tfontptr->dvi_alen = GET1(G_dvifp);    /* area length for font name */
  1832.     tfontptr->dvi_nlen = GET1(G_dvifp);    /* device length */
  1833.  
  1834.     /* get font name string - according to dvi file (no mag) */
  1835.     /* note that this also gets the dvi area/directory */
  1836.     /* which is usually not present, but could be a bug */
  1837.     GetBytes(G_dvifp, tfontptr->dvi_name, tfontptr->dvi_alen+tfontptr->dvi_nlen);
  1838.     tfontptr->dvi_name[tfontptr->dvi_alen+tfontptr->dvi_nlen] = '\0';
  1839.  
  1840.     tfontptr->font_space = tfontptr->dvi_s/6;    /* never used */
  1841.  
  1842. #ifdef USEPXL
  1843. #ifdef USEGLOBALMAG
  1844.     tfontptr->font_mag = (int)((
  1845.     ActualFactor((int)
  1846.         (((float)tfontptr->dvi_s/(float)tfontptr->dvi_d)*1000.0 + 0.5)
  1847.         )
  1848.     * ActualFactor(D_mag) * (float)RESOLUTION * 5.0) + 0.5);
  1849. #else not USEGLOBALMAG
  1850.     tfontptr->font_mag = (int)((
  1851.     ActualFactor((int)
  1852.         (((float)tfontptr->dvi_s/(float)tfontptr->dvi_d)*1000.0 + 0.5)
  1853.         )
  1854.     * (float)RESOLUTION * 5.0) + 0.5);
  1855. #endif USEGLOBALMAG
  1856. #else not USEPXL
  1857. #ifdef USEGLOBALMAG
  1858.     tfontptr->font_mag = (int)((
  1859.     ActualFactor((int)
  1860.         (((float)tfontptr->dvi_s/(float)tfontptr->dvi_d)*1000.0 + 0.5)
  1861.         )
  1862.     * ActualFactor(D_mag) * (float)RESOLUTION) + 0.5);
  1863. #else not USEGLOBALMAG
  1864.     tfontptr->font_mag = (int)((
  1865.     ActualFactor((int)
  1866.         (((float)tfontptr->dvi_s/(float)tfontptr->dvi_d)*1000.0 + 0.5)
  1867.         )
  1868.     * (float)RESOLUTION) + 0.5);
  1869. #endif USEGLOBALMAG
  1870. #endif USEPXL
  1871.  
  1872.     /* for debugging */
  1873. #ifdef DEBUG
  1874.     if (Debug) {
  1875.     fprintf(stderr,"ReadFontDef k=%d c=%d s=%d d=%d a=%d l=%d n=%s mag=%d gmag=%d\n",
  1876.         tfontptr->dvi_fnum,
  1877.         tfontptr->dvi_check,
  1878.         tfontptr->dvi_s,
  1879.         tfontptr->dvi_d,
  1880.         tfontptr->dvi_alen,
  1881.         tfontptr->dvi_nlen,
  1882.         tfontptr->dvi_name,
  1883.         tfontptr->font_mag,
  1884.         D_mag
  1885.     );
  1886.     }
  1887. #endif DEBUG
  1888.  
  1889.     /* go find the font file */
  1890.     if (!FindFontFile(G_fontpath,G_fontpathsize,
  1891.         tfontptr->dvi_name,tfontptr->font_mag,tfontptr->name,
  1892.         nname, &nmag)) {
  1893.     Fatal("no font %s.%d\n",tfontptr->dvi_name,tfontptr->font_mag);
  1894.     }
  1895.  
  1896.     /* set postscript font name - dvi name plus mag (i.e. file name) */
  1897.     sprintf(tfontptr->psname, "%s.%d", tfontptr->dvi_name, tfontptr->font_mag);
  1898.     if (tfontptr != G_pfontptr) OpenFontFile();
  1899.  
  1900. #ifdef USEPXL
  1901.     /* allow missing pxl files */
  1902.     if ( G_fontfp == NO_FILE ) {
  1903.     tfontptr->magnification = 0;
  1904.     tfontptr->designsize = 0;
  1905.     /* initialize the character data */
  1906.     for (i = 0; i <= MAXFONTCHARS-1; i++) {
  1907.         tcharptr = &(tfontptr->ch[i]);
  1908.         tcharptr->width = 0;
  1909.         tcharptr->height = 0;
  1910.         tcharptr->xOffset= 0;
  1911.         tcharptr->yOffset = 0;
  1912.         tcharptr->where.isloaded = FALSE;
  1913.         tcharptr->where.address.fileOffset = NONEXISTANT;
  1914.         tcharptr->tfmw = 0;
  1915.     }
  1916.     return;
  1917.     }
  1918.  
  1919.     /* check the version number */
  1920.     if ((t = GET4(G_fontfp)) != PXLID) {
  1921.     Fatal("PXL ID = %d, can only process PXL ID = %d files", t, PXLID);
  1922.     }
  1923.  
  1924.     /* check that the "checksum" matches */
  1925.     fseek(G_fontfp, -20, FROM_END);    /* magic number */
  1926.     t = GET4(G_fontfp);
  1927.     if ((tfontptr->dvi_check != 0) && (t != 0) && (tfontptr->dvi_check != t)) {
  1928.     Warning("font = \"%s\",\n-->font checksum = %d,\n-->dvi checksum = %d",
  1929.         tfontptr->name, tfontptr->dvi_check, t);
  1930.     }
  1931.  
  1932.     tfontptr->magnification = GET4(G_fontfp);
  1933.     tfontptr->designsize = GET4(G_fontfp);
  1934.  
  1935.     /* get the character info */
  1936.     fseek(G_fontfp, GET4(G_fontfp) * 4, FROM_START);
  1937.  
  1938.     for (i = 0; i <= MAXFONTCHARS-1; i++) {
  1939.     tcharptr = &(tfontptr->ch[i]);
  1940.     tcharptr->width = GET2(G_fontfp);
  1941.     tcharptr->height = GET2(G_fontfp);
  1942.     tcharptr->xOffset= GETSN(G_fontfp, 2);
  1943.     tcharptr->yOffset = GETSN(G_fontfp, 2);
  1944.     tcharptr->where.isloaded = FALSE;
  1945.     tcharptr->where.address.fileOffset = GET4(G_fontfp) * 4;
  1946.     tcharptr->tfmw = ((float)GET4(G_fontfp)*(float)tfontptr->dvi_s) /
  1947.         (float)(1<<20);
  1948.     }
  1949.  
  1950. #else not USEPXL
  1951.     /* allow missing gf files */
  1952.     if ( G_fontfp == NO_FILE ) {
  1953.     for (i = 0; i <= MAXFONTCHARS-1; i++) {
  1954.         tcharptr = &(tfontptr->ch[i]);
  1955.         tcharptr->where.isloaded = FALSE;
  1956.         tcharptr->where.address.fileOffset = NONEXISTANT;
  1957.         tcharptr->tfmw = 0;
  1958.     }
  1959.     return;
  1960.     }
  1961.  
  1962.     /* get the character info from gf font file */
  1963.     gf_infile = G_fontfp;
  1964.     gf_filename = tfontptr->name;        /* used in gf reader */
  1965.     gf_seekpost();
  1966.     gf_readpost();
  1967.  
  1968.     /* check the checksum */
  1969.     if ((tfontptr->dvi_check != 0)
  1970.         && (gf_checksum != 0)
  1971.         && (tfontptr->dvi_check != gf_checksum)) {
  1972.     Warning("font = \"%s\",\n-->font checksum = %d,\n-->dvi checksum = %d",
  1973.         tfontptr->name, tfontptr->dvi_check, gf_checksum);
  1974.     }
  1975.  
  1976.     /* initialize the character info */
  1977.     for(i=0; i<=MAXFONTCHARS-1; i++) {
  1978.     tcharptr = &(tfontptr->ch[i]);
  1979.     tcharptr->where.isloaded = FALSE;
  1980.     if (gf_char_exists[i]) {
  1981.         tcharptr->tfmw = ((float)gf_tfm_wd[i]*(float)tfontptr->dvi_s) /
  1982.         (float)(1<<20);
  1983.         tcharptr->where.address.fileOffset = gf_char_pointer[i];
  1984.     } else {
  1985.         tcharptr->where.address.fileOffset = NONEXISTANT;
  1986.         tcharptr->tfmw = 0;
  1987.     }
  1988.     }
  1989. #endif not USEPXL
  1990. }
  1991.  
  1992. /*-->FindPostAmble*/
  1993. /**********************************************************************/
  1994. /************************  FindPostAmble  **************************/
  1995. /**********************************************************************/
  1996. /* this routine will move to the end of the file and find the start
  1997.     of the postamble */
  1998.  
  1999. void
  2000. FindPostAmble()
  2001. {
  2002.     register long postambleptr;
  2003.     register int i;
  2004.  
  2005.     /* this seems like a dumb way to do this */
  2006.     /* why not just seek 4 from end */
  2007.     fseek (G_dvifp, (long) 0, FROM_END);   /* goto end of file */
  2008.     postambleptr = ftell (G_dvifp) - 4;
  2009.     fseek (G_dvifp, postambleptr, FROM_START);
  2010.  
  2011.     while (TRUE) {
  2012.     fseek (G_dvifp, --(postambleptr), FROM_START);
  2013.     if (((i = GET1(G_dvifp)) != 223) && (i != DVIFORMAT)) {
  2014.         Fatal ("Bad end of DVI file");
  2015.     }
  2016.     if (i == DVIFORMAT) break;
  2017.     }
  2018.     fseek (G_dvifp, (postambleptr) - 4, FROM_START);
  2019.     postambleptr = GET4(G_dvifp);
  2020.     G_postambleptr = postambleptr;
  2021.     fseek (G_dvifp, postambleptr, FROM_START);
  2022. }
  2023.  
  2024. /*-->CheckPreAmble*/
  2025. /**********************************************************************/
  2026. /**************************  CheckPreAmble  ***************************/
  2027. /**********************************************************************/
  2028.  
  2029. void
  2030. CheckPreAmble()
  2031. {
  2032.     register int i;
  2033.  
  2034.     /* check for presence of pre-amble */
  2035.     if ((i = GET1(G_dvifp)) != PRE)  {
  2036.     Fatal("PRE doesn't occur first--are you sure this is a DVI file?\n\n");
  2037.     }
  2038.  
  2039.     /* check for correct DVI file format */
  2040.     i = GET1(G_dvifp);
  2041.     if (i != DVIFORMAT)  {
  2042.     Fatal("DVI format = %d, can only process DVI format %d files\n\n",
  2043.         i, DVIFORMAT);
  2044.     }
  2045. }
  2046.  
  2047. /*-->ReadPreAmble*/
  2048. /**********************************************************************/
  2049. /**************************  ReadPreAmble  ***************************/
  2050. /**********************************************************************/
  2051.  
  2052. void
  2053. ReadPreAmble()
  2054. {
  2055.     char sname[STRSIZE];
  2056.     register int k;
  2057.  
  2058.     /* read the preamble */
  2059.     D_num = GET4(G_dvifp);
  2060.     D_den = GET4(G_dvifp);
  2061.     D_mag = GET4(G_dvifp);
  2062.  
  2063. #ifdef USEGLOBALMAG
  2064.     if (CL_usermag > 0 && CL_usermag != D_mag) {
  2065.     Warning("DVI magnification of %d over-ridden by user mag of %d\n",
  2066.             D_mag, CL_usermag );
  2067.     }
  2068. #endif USEGLOBALMAG
  2069.  
  2070.     if (CL_usermag > 0) D_mag = CL_usermag;
  2071.  
  2072. #ifndef USEGLOBALMAG
  2073.     if( D_mag != 1000 ) Warning("Magnification of %d ignored.\n", D_mag);
  2074. #endif USEGLOBALMAG
  2075.  
  2076.     G_hconv = DoConv(D_num, D_den, hconvRESOLUTION);
  2077.     G_vconv = DoConv(D_num, D_den, vconvRESOLUTION);
  2078.     k = GET1(G_dvifp);
  2079.     GetBytes(G_dvifp, sname, k);
  2080.     sname[k] = '\0';
  2081. #ifdef DEBUG
  2082.     if (Debug) Warning("internal - pre-string - %s\n",sname);
  2083. #endif DEBUG
  2084.  
  2085.     /* read the post-amble */
  2086.     ReadPostAmble(CL_PreLoad);
  2087.     if (CL_Reverse) {
  2088.     /* start on last page */
  2089.     fseek(G_dvifp, G_ppagep, FROM_START);
  2090.     } else {
  2091.     /* start on first page */
  2092.     fseek(G_dvifp, (long) 14, FROM_START);
  2093.     k = GET1(G_dvifp);
  2094.     GetBytes(G_dvifp, sname, k);
  2095.     }
  2096. }
  2097.  
  2098. /*-->ReadPostAmble*/
  2099. /**********************************************************************/
  2100. /**************************  ReadPostAmble  ***************************/
  2101. /**********************************************************************/
  2102. /***********************************************************************
  2103.     This  routine  is  used  to  read  in  the  postamble  values.    It
  2104.     initializes the magnification and checks  the stack height prior  to
  2105.     starting printing the document.
  2106. ***********************************************************************/
  2107.  
  2108. void
  2109. ReadPostAmble(load)
  2110. int     load;
  2111. {
  2112.     /* go find the post-amble */
  2113.     FindPostAmble();
  2114.     if (GET1(G_dvifp) != POST) Fatal ("POST missing at head of postamble");
  2115. #ifdef DEBUG
  2116.     if (Debug) fprintf (stderr, "got POST command\n");
  2117. #endif DEBUG
  2118.     G_ppagep = GET4(G_dvifp);
  2119.     D_num = GET4(G_dvifp);
  2120.     D_den = GET4(G_dvifp);
  2121.     D_mag = GET4(G_dvifp);
  2122. #ifdef USEGLOBALMAG
  2123.     if( CL_usermag > 0 && CL_usermag != D_mag )
  2124.     Warning("DVI magnification of %d over-ridden by user mag of %d\n", D_mag, CL_usermag );
  2125. #endif USEGLOBALMAG
  2126.     if( CL_usermag > 0 ) D_mag = CL_usermag;
  2127. #ifndef USEGLOBALMAG
  2128.     if( D_mag != 1000 ) Warning("Magnification of %d ignored.\n", D_mag);
  2129. #endif USEGLOBALMAG
  2130.     G_hconv = DoConv(D_num, D_den, hconvRESOLUTION);
  2131.     G_vconv = DoConv(D_num, D_den, vconvRESOLUTION);
  2132.  
  2133.     GET4(G_dvifp);    /* height-plus-depth of tallest page */
  2134.     GET4(G_dvifp);    /* width of widest page */
  2135.     if (GET2(G_dvifp) >= STACKSIZE)
  2136.     Fatal ("Stack size is too small - static allocation");
  2137.     GET2(G_dvifp);    /* this reads the number of pages in */
  2138.     /* the DVI file */
  2139. #ifdef DEBUG
  2140.     if (Debug) fprintf (stderr, "now reading font defs");
  2141. #endif DEBUG
  2142.     if (load) GetFontDef ();
  2143. }
  2144.  
  2145. /*-->LoadAChar*/
  2146. /**********************************************************************/
  2147. /*****************************  LoadAChar  ******************************/
  2148. /**********************************************************************/
  2149. /* control the output of a character bit map */
  2150. /* 1. read the bitmap from the font file */
  2151. /* 2. emit the bitmap to the output */
  2152.  
  2153. LoadAChar(ch, ceptr)
  2154.     int ch;
  2155.     register struct char_entry *ceptr;
  2156. {
  2157.     /* sanity checks */
  2158.     if (ceptr == NULL) {
  2159.     Fatal("internal - null pointer in LoadAChar\n");
  2160.     }
  2161.     if (ceptr->where.isloaded) {
  2162.     /* should not have been called */
  2163.     return;
  2164.     }
  2165.  
  2166.     /* always set these values - here are the defaults */
  2167.     ceptr->where.isloaded = TRUE;
  2168.  
  2169.     /* if there is no font file, no need to proceed */
  2170.     if (ceptr->where.address.fileOffset == NONEXISTANT) {
  2171.     ceptr->where.address.pixptr = NULL;
  2172.     return;
  2173.     }
  2174.  
  2175.     /* first open the font file */
  2176.     /* note current font is global variable G_fontptr */
  2177.     OpenFontFile();
  2178.  
  2179.     /* next read the bit map for this character from the font file */
  2180. #ifdef USEPXL
  2181.     fseek(G_fontfp, ceptr->where.address.fileOffset, FROM_START);
  2182.     nints = ((ceptr->width + 31) >> 5) * ceptr->height;
  2183.     if( (pr = (long *)malloc( nints*sizeof(long) )) == NULL ) {
  2184.     Fatal("Unable to allocate memory for char bit map\n");
  2185.     }
  2186.     fread(pr, 4, nints, G_fontfp);
  2187.     ceptr->where.address.pixptr = pr;
  2188.  
  2189. #else not USEPXL
  2190.  
  2191. #ifdef NOTDEF
  2192.     /* unless re-read postamble of font file, may have lost file offsets */
  2193.     gf_seekchar(ch);
  2194. #endif NOTDEF
  2195.     fseek(gf_infile, ceptr->where.address.fileOffset, FROM_START);
  2196.     gf_gettochar();
  2197.     gf_readbits();
  2198.     ceptr->where.address.pixptr = NULL;
  2199.  
  2200. #endif USEPXL
  2201.  
  2202.     /* now emit the bit map to the output */
  2203.     EmitCharBitMap(ch, ceptr);
  2204. #ifdef USEPXL
  2205.     /* we should really free the space used by the PXL data after this
  2206.        point, but it is not large, and besides, we may want to be
  2207.        more clever in the future, about sending bitmaps.  So keep
  2208.        the data around */
  2209. #endif USEPXL
  2210. }
  2211.  
  2212. /*-->SetChar*/
  2213. /**********************************************************************/
  2214. /*****************************  SetChar  ******************************/
  2215. /**********************************************************************/
  2216.  
  2217. void
  2218. SetChar(ch, command, PassNo)
  2219.     int ch, command, PassNo;
  2220. {
  2221.     register struct char_entry *ceptr;  /* temporary char_entry pointer */
  2222.  
  2223.     /* who sets G_fontptr? (OpenFontFile,SetFontNum) */
  2224.     if (G_fontptr == NULL) {
  2225.     Fatal("internal - unexpected null font in SetChar()\n");
  2226.     }
  2227.     ceptr = &(G_fontptr->ch[ch]);
  2228.     if (!ceptr->where.isloaded) LoadAChar(ch, ceptr);
  2229.     if (PassNo==0) return;
  2230.  
  2231.     SetPosn(G_h,G_v);
  2232.     if (G_fontptr->font_file_id != NO_FILE) {      /* ignore missing fonts */
  2233.     EMITN(ch); EMITS("c\n");
  2234.     G_hh += ceptr->tfmw;
  2235.     }
  2236.  
  2237.     /* if this is a set, then move, if this is a put, then do not move */
  2238.     if (command <= SET4) MoveOver(ceptr->tfmw);
  2239.  
  2240. #ifdef STATS
  2241.     S_tnc += 1;
  2242.     G_fontptr->ncts += 1;
  2243. #endif STATS
  2244. }
  2245.  
  2246. /*-->SetFontNum*/
  2247. /**********************************************************************/
  2248. /****************************  SetFontNum  *****************************/
  2249. /**********************************************************************/
  2250. /*  this routine is used to specify the font to be used in printing future
  2251.     characters */
  2252.  
  2253. void
  2254. SetFontNum(fontnum, Emitting)
  2255.     int fontnum, Emitting;
  2256. {
  2257.     register struct font_entry *fontp;
  2258.  
  2259.     /* linear search of font entry list */
  2260.     fontp = G_hfontptr;
  2261.     while ((fontp != NULL) && (fontp->dvi_fnum != fontnum)) {
  2262.     fontp = fontp->next;
  2263.     }
  2264.     if (fontp == NULL) {
  2265.     Fatal("font %d undefined", fontnum);
  2266.     }
  2267.     if (Emitting && (fontp->font_file_id != NO_FILE) )  {
  2268.     EMIT(G_outfp,"%s @sf\n", fontp->psname);
  2269.     }
  2270.     G_fontptr = fontp;
  2271. }
  2272.  
  2273. /*-->SetPosn*/
  2274. /**********************************************************************/
  2275. /*****************************  SetPosn  ******************************/
  2276. /**********************************************************************/
  2277. /* output a positioning command */
  2278.  
  2279. void
  2280. SetPosn(x, y)
  2281.     int x, y;
  2282. {
  2283.     register int rx;
  2284. #ifdef NOTDEF
  2285.     register int ry;
  2286. #endif NOTDEF
  2287.  
  2288. #ifdef USERELPOS
  2289.     /* use relative movement if just moving horizontally */
  2290.     if (y == G_vv) {
  2291.         if ( x != G_hh ) {
  2292.         EMITN(rx=PixRound(x-G_hh,G_hconv));
  2293.         EMITS("r ");
  2294.         G_hh += rx*G_hconv;
  2295.         }
  2296.     } else {
  2297. #endif USERELPOS
  2298.         EMITN(rx=PixRound(x,G_hconv));
  2299.         EMITN(PixRound(y,G_vconv));
  2300. #ifdef NOTDEF
  2301.         EMITN(ry=PixRound(y,G_vconv));
  2302. #endif NOTDEF
  2303.         EMITS("p ");
  2304.  
  2305.         /* must know where device "really" is horizontally, */
  2306.         /* for rel. posning. */
  2307.         /* but we always use direct positioning for vertical movement */
  2308.         G_hh = rx*G_hconv;
  2309.         G_vv = y;
  2310. #ifdef USERELPOS
  2311.     }
  2312. #endif USERELPOS
  2313. }
  2314.  
  2315. /*-->SetRule*/
  2316. /**********************************************************************/
  2317. /*****************************  SetRule  ******************************/
  2318. /**********************************************************************/
  2319. /* this routine will draw a rule (a line) */
  2320.  
  2321. void
  2322. SetRule(a, b, Set)
  2323.     int a, b;
  2324.     BOOLEAN Set;
  2325. {
  2326.     if( a > 0 && b > 0 ) {
  2327.     SetPosn(G_h,G_v);        /* lower left corner */
  2328.     EMITN(PixRound(b,G_hconv));    /* width */
  2329.     EMITN(PixRound(a,G_vconv));    /* height */
  2330.     EMITS("ru\n");
  2331.     } else {
  2332.     Warning("internal - bad value to SetRule (%d,%d)\n",a,b);
  2333.     }
  2334.     /* perform a move also? true for set, false for put */
  2335.     if (Set) MoveOver(b);
  2336. }
  2337.  
  2338. /*-->SetString*/
  2339. /**********************************************************************/
  2340. /*****************************  SetString  ****************************/
  2341. /**********************************************************************/
  2342. /* read and set a consecutive string of chars */
  2343.  
  2344. void
  2345. SetString(firstch, PassNo)
  2346.     register int firstch;
  2347.     int PassNo;
  2348. {
  2349.     register int ch;
  2350.     register struct char_entry *ceptr;
  2351.     register struct font_entry *fontp;
  2352.     register int len;
  2353.  
  2354.     /* sanity check */
  2355.     fontp = G_fontptr;
  2356.     if (fontp == NULL) {
  2357.     Fatal("internal - null font pointer - SetString()\n");
  2358.     }
  2359.  
  2360.     /* on the first pass, just read string and load fonts */
  2361.     if (PassNo == 0) {
  2362.     /* read entire string of chars */
  2363.     for (ch = firstch; ch >= SETC_000 && ch <= SETC_127; ch = GET1(G_dvifp)) {
  2364.         ceptr = &(fontp->ch[ch]);
  2365.         if (!(ceptr->where.isloaded)) LoadAChar(ch, ceptr);
  2366.     }
  2367.     UNGET1(G_dvifp, ch);    /* backup one character */
  2368.     return;
  2369.     }
  2370.  
  2371.     /* this is the second pass - emit */
  2372.     len = 1;
  2373.     SetPosn(G_h,G_v);
  2374.  
  2375.     /* alway emit the first character, so compute movement */
  2376.     ceptr = &(fontp->ch[firstch]);
  2377.     G_h += ceptr->tfmw;
  2378.     /* ignore missing fonts */
  2379.     if (fontp->font_file_id != NO_FILE) {
  2380.     /* this will force a movement by SetPosn() later */
  2381.     G_hh += ceptr->tfmw;
  2382.     }
  2383.  
  2384.     /* read entire string of chars */
  2385.     /* first check for more compact case of one char */
  2386.     ch = GET1(G_dvifp);
  2387.     if (ch < SETC_000 || ch > SETC_127) {
  2388.     /* only one character to emit */
  2389.     EMITN(firstch); 
  2390.     EMITS("c\n"); 
  2391.     } else {
  2392.     /* start a sting */
  2393.     EMITC('(');
  2394.     /* emit the first char */
  2395.     if ((firstch < ' ') || (firstch >= 0177)) {
  2396.         /* non-printable character */
  2397.         EMITO(firstch);
  2398.     } else if (firstch == '(' || firstch == ')' || firstch == '\\') {
  2399.         /* escaped character */
  2400.         EMITC('\\'); 
  2401.         EMITC(firstch); 
  2402.     } else {
  2403.         EMITC(firstch);
  2404.     }
  2405.     while (ch >= SETC_000 && ch <= SETC_127) {
  2406.         len += 1;
  2407.         /* move the current location accordingly */
  2408.         ceptr = &(fontp->ch[ch]);
  2409.         G_h += ceptr->tfmw;
  2410.         /* ignore missing fonts */
  2411.         if (fontp->font_file_id != NO_FILE) {
  2412.         if (ch < ' ' || ch >= 0177) {
  2413.             EMITO(ch);
  2414.         } else if (ch == '(' || ch == ')' || ch == '\\') {
  2415.             EMITC('\\'); 
  2416.             EMITC(ch); 
  2417.         } else {
  2418.             EMITC(ch);
  2419.         }
  2420.         /* this will force a movement by SetPosn() later */
  2421.         G_hh += ceptr->tfmw;
  2422.         }
  2423.         ch = GET1(G_dvifp);
  2424.     }
  2425.     EMITS(") s\n");
  2426.     }
  2427.     UNGET1(G_dvifp, ch);    /* backup one character */
  2428.  
  2429. #ifdef STATS
  2430.     S_tnc += len;
  2431.     fontp->ncts += len;
  2432. #endif STATS
  2433. }
  2434.  
  2435. /*-->SignExtend*/
  2436. /**********************************************************************/
  2437. /****************************  SignExtend  ****************************/
  2438. /**********************************************************************/
  2439.  
  2440. int
  2441. SignExtend(fp, n)   /* return n byte quantity from file fd */
  2442. register FILE *fp;  /* file pointer    */
  2443. register int n;     /* number of bytes */
  2444. {
  2445.     int n1;     /* number of bytes        */
  2446.     register int x; /* number being constructed */
  2447.  
  2448.     x = getc(fp);   /* get first (high-order) byte */
  2449.     n1 = n--;
  2450.     while (n--)  {
  2451.     x <<= 8;
  2452.     x |= getc(fp);
  2453.     }
  2454.  
  2455.     /* NOTE: This code assumes that the right-shift is an arithmetic, rather
  2456.     than logical, shift which will propagate the sign bit right.   According
  2457.     to Kernighan and Ritchie, this is compiler dependent! */
  2458.  
  2459.     x<<=32-8*n1;
  2460.     x>>=32-8*n1;  /* sign extend */
  2461.  
  2462. #ifdef DEBUG
  2463.     if (Debug) {
  2464.     fprintf(stderr,"\tSignExtend(fp,%d)=%X\n",n1,x);
  2465.     }
  2466. #endif DEBUG
  2467.     return(x);
  2468. }
  2469.  
  2470. /*-->SkipFontDef*/
  2471. /**********************************************************************/
  2472. /****************************  SkipFontDef  ***************************/
  2473. /**********************************************************************/
  2474.  
  2475. void
  2476. SkipFontDef()
  2477. {
  2478.     register int a, l;
  2479.  
  2480.     SKIP(G_dvifp,12);
  2481.     a = GET1(G_dvifp);
  2482.     l = GET1(G_dvifp);
  2483.     SKIP(G_dvifp,a+l);
  2484. }
  2485.  
  2486. /*-->Progress*/
  2487. /**********************************************************************/
  2488. /*****************************  Progress  ******************************/
  2489. /**********************************************************************/
  2490. /* all communication to the user about progress goes through here */
  2491. /* VARARGS1 for lint */
  2492.  
  2493. void
  2494. Progress(fmt, a, b, c, d, e, f)    /* issue a warning */
  2495. char *fmt;            /* format   */
  2496. char *a, *b, *c, *d, *e, *f;    /* arguments */
  2497. {
  2498.     /* only print if not quiet */
  2499.     if (G_quiet) return;
  2500.     fprintf(stderr, fmt, a, b, c, d, e, f);
  2501.  
  2502.     /* print in log file, if logging */
  2503.     if (G_logging) {
  2504.     if (G_logfp == NULL) {
  2505.         Fatal("missing log file\n");
  2506.     }
  2507.     fprintf(G_logfp, fmt, a, b, c, d, e, f);
  2508.     }
  2509. }
  2510.  
  2511. /*-->Warning*/
  2512. /**********************************************************************/
  2513. /*****************************  Warning  ******************************/
  2514. /**********************************************************************/
  2515. /* why is this routine so complicated? */
  2516. /* why is this routine used in some places and not in others? */
  2517. /* is G_logfp different than stderr? */
  2518. /* VARARGS1 for lint */
  2519.  
  2520. void
  2521. Warning(fmt, a, b, c, d, e, f)    /* issue a warning */
  2522. char *fmt;            /* format   */
  2523. char *a, *b, *c, *d, *e, *f;    /* arguments */
  2524. {
  2525.     G_errenc = TRUE;
  2526.     if (G_nowarn) return;
  2527.     fprintf(stderr, "%s: ", G_progname);
  2528.     fprintf(stderr, fmt, a, b, c, d, e, f);
  2529.  
  2530.     /* print in log file, if logging */
  2531.     if (G_logging) {
  2532.     if (G_logfp == NULL) {
  2533.         Fatal("missing log file\n");
  2534.     }
  2535.     fprintf(G_logfp, "%s: ", G_progname);
  2536.     fprintf(G_logfp, fmt, a, b, c, d, e, f);
  2537.     }
  2538. }
  2539.  
  2540. /**********************************************************************/
  2541.  
  2542.